Come posso vedere un file sorgente C / C ++ dopo l'elaborazione preliminare in Visual Studio?

Diciamo che ho un file sorgente con molte direttive preprocessore. È possibile vedere come appare dopo aver fatto il preprocessore?

cl.exe, l'interfaccia della riga di comando di Microsoft Visual C ++, ha tre diverse opzioni per l'output del file preelaborato (da cui l'incoerenza nelle risposte precedenti su Visual C ++):

• /E: preprocessa a stdout (simile all'opzione -E di GCC)
• /P: preprocessa al file
• /EP: preprocessa allo stdout senza le direttive #line

Se si desidera preelaborare un file senza le direttive #line, combinare le opzioni /Pe /EP.

La maggior parte dei compilatori ha un'opzione per eseguire il preprocessore. ad esempio , gcc fornisce -E:

   -E  Stop after the preprocessing stage; do not run the compiler proper.  
       The output is in the form of preprocessed source code, which is sent
       to the standard output.

Quindi puoi semplicemente eseguire:

gcc -E foo.c

Se non riesci a trovare tale opzione, puoi anche trovare il preprocessore C sul tuo computer. Di solito si chiama cpp ed è probabilmente già nel tuo percorso. Invocalo in questo modo:

cpp foo.c

Se ci sono intestazioni che devi includere da altre directory, puoi passare -I / path / a / include / dir a una di queste, proprio come faresti con una normale compilazione.

Per Windows, lo lascerò ad altri poster per fornire risposte in quanto non sono esperto lì.

Fare clic con il tasto destro del mouse su Esplora soluzioni, vai a Proprietà. In Proprietà di configurazione-> C / C ++ -> Preprocessore, "Genera file preelaborato" è quello che stai cercando. Quindi fare clic con il tasto destro sul file in Esplora soluzioni e selezionare "Compila". Il file preelaborato viene creato nella directory di output (ad esempio Release, Debug) con un'estensione .i (grazie a Steed per il suo commento).

In genere è necessario eseguire un po 'di postelaborazione sull'output del preprocessore, altrimenti tutte le macro si espandono in una sola riga, che è difficile da leggere ed eseguire il debug. Per il codice C, sarebbe sufficiente qualcosa di simile al seguente:

gcc -E code.c | sed '/^\#/d' | indent -st -i2 > code-x.c

Per il codice C ++, in realtà è molto più difficile. Per GCC / g ++, ho trovato utile questo script Perl .

Non so nulla del compilatore Microsoft, ma su GCC puoi usare questo:

gcc -E -P -o result.c my_file.h

Se vuoi vedere i commenti usa questo:

gcc -E -C -P -o result.c my_file.h

Altre opzioni disponibili in questa pagina .

Prova cl /EPse stai utilizzando il compilatore C ++ di Microsoft.

In Visual Studio è possibile compilare un file (o progetto) con / P.

Quando bk1e e Andreas M. hanno risposto, l'opzione / P per il compilatore lo farà preelaborare un file. Tuttavia, nel mio progetto utilizzando VS2005 e Platform Builder (per un processore ARM incorporato), il progetto non ha presentato un'opzione nella finestra di dialogo (come descritto da Jim B) per abilitare tale opzione.

Potrei eseguire CL manualmente e aggiungere / P, ma non è riuscito perché non conoscevo tutte le opzioni appropriate della riga di comando che erano state invisibilmente attivate da Platform Builder durante la compilazione completa. Quindi avevo bisogno di sapere tutte quelle opzioni.

La mia soluzione era quella di andare a cercare nel file build.log e trovare la riga che veniva eseguita

CL blah-blah-blah myfile.c

Ho copiato questa riga negli appunti. La parte "blah-blah-blah" conteneva le opzioni di costruzione ed era enorme.

Di nuovo nell'IDE, ho fatto clic con il pulsante destro del mouse su myfile.c, ho scelto "Apri finestra di build", quindi in quella finestra ho incollato la riga di comando di build e ho aggiunto un "/ P".

CL /P blah-blah-blah myfile.c

Fatto. È stato prodotto il file myfile.i, che conteneva l'output del preprocessore.

CPIP è un nuovo preprocessore C / C ++ scritto in Python. Se si desidera una rappresentazione visiva dettagliata di un file preelaborato, provare.

CPIP è un pre-processore C / C ++ implementato in Python. La maggior parte dei pre-processori considera la pre-elaborazione come un lavoro sporco che deve essere fatto appena possibile. Ciò può rendere molto difficile rintracciare i sottili difetti nella fase di pre-elaborazione poiché i pre-processori scaricano molte informazioni utili a favore di ottenere il risultato nel modo più economico possibile.

Pochi sviluppatori capiscono davvero la pre-elaborazione, per molti è un po 'oscura di magia nera. CPIP mira a migliorarlo e registrando ogni dettaglio della preelaborazione in modo che CPIP possa produrre meravigliosamente informazioni visive sulle dipendenze dei file, sull'utilizzo delle macro e così via.

CPIP non è progettato per essere un sostituto di cpp (o di qualsiasi altro pre-processore stabilito), invece CPIP considera la chiarezza e la comprensione più importanti della velocità di elaborazione.

Sul sistema operativo Windows, una semplice risposta di una riga a questa domanda è utilizzare il comando seguente nel prompt di DOS per visualizzare il file preelaborato:

CL /P /C myprogram.c

Questo genererà un file chiamato myprogram.i . Aprilo e cerca i tuoi preprocessori espansi.