Ho una macro piuttosto complicata all'interno del mio codice C++ (non gestito). C'è un modo per espandere le macro in VS debugger? O forse c'è un altro modo per eseguire il debug di macro lì?Come eseguire il debug di macro in modo efficiente in VS?
F.e. Mi piacerebbe inserire un punto di interruzione al suo interno.
(sì, lo so macro sono cattivi.)
andare o di progetto o file di origine proprietà facendo clic destro e andare a "Proprietà". In Proprietà di configurazione-> C/C++ -> Preprocessore, impostare "Genera file preelaborato" con o senza numeri di riga, a seconda di quale si preferisce. Questo mostrerà ciò che la tua macro si espande nel contesto. Se hai bisogno di eseguire il debug sul codice compilato dal vivo, basta tagliarlo e incollarlo e metterlo al posto della tua macro durante il debug.
Il compilatore espande le macro piacevolmente. Ottieni un elenco di compilation con le macro espanse.
Inserire la macro espansa nel codice. Ricompila e dovresti essere in grado di attraversarlo, per fare un semplice test.
Generalmente quando sto costruendo una macro complicata, I codice rigido prima e testarlo. Quindi lo trasformo in una macro.
Per il 2008, this può essere di aiuto
Non riuscivo davvero a trovare come espandere automaticamente i macro. So che posso farlo a mano, ma mi aspetto che l'IDE possa farlo ... come il comando di espansione di GDB. – liori
è possibile eseguire un preprocessore C su un file di origine per espandere tutte le macro. – n0rd
Quando si esegue separatamente il preprocessore, tenere presente che potrebbe avere un'idea diversa di quali macro/costanti sono predefinite (in particolare, quelle specifiche per piattaforma/compilatore). Sono stato morso da questo! –
Contrastare un male con un metodo di eversione. Espandi una istanza della macro a mano, fino a quando non finisci il debug, o l'utility cpp può aiutarti ad espandere tutte le macro, ma non sono sicuro che ci sia una versione Windows di esso.
Ho detto che le macro sono molto complicate? Mi piacerebbe ampliare uno o due strati non solo, tutte le macro (altrimenti è chiaramente illeggibile) ... durante il debug
Se non ci sono troppi macro che non si desidera espandere , quindi puoi semplicemente #undef prima dello snippet che vuoi eseguire il debug. Quindi compilare con [Genera file preelaborato] come menzionato sopra. La compilazione avrà esito negativo ma si otterrà un taglio utilizzabile nell'output preelaborato con le espansioni corrette. Copia-incolla, rimuovi # undef-s e debug.
Purtroppo, i tuoi migliori amici per affrontare con le macro C-stile sono linea, modello e un buon compilatore ottimizzato.
Sto cercando di ingannare il codice esistente, non di riscriverlo. Quindi inline e modelli non mi aiuteranno qui. – liori
Utilizzare le funzioni inline (forzare in linea se lo si intende veramente) e attenersi ad esso! Ciò sarà più efficiente (si ottiene solo se è in linea se offre prestazioni se si ottimizza per il perf) e se è mantenibile. Si perde molto usando le macro: digitare controllo sicurezza &.
Le macro non esistono per il compilatore, funzionano solo per il preprocessore. Questo fa sostituire il testo senza cercare effetti collaterali. Quindi le macro non vengono mai chiamate e non è possibile eseguirne il debugging. Non importa come si codifica una macro, l'uso improprio è sempre possibile. Come in questo esempio:
#define SQUARE(a) ((a)*(a))
nota già la ( `) 'per la protezione contro le sostituzioni come SQUARE (3 + 2).Ma non proteggono da:
int a = 1;
int b = SQUARE(++a);
Ci si aspetterebbe che fosse 4 ma si finisce con 6 che non è proprio quadrato. Come si espande a int b = (++a)*(++a); Non avresti questo problema con le funzioni inline.
Si noti che l'implementazione di una funzione inline deve essere visibile per il compilatore nei punti in cui viene utilizzata. Anche il debugging sarà strano per l'utente inesperto: poiché ci sono molte istanze di una funzione inline, otterrai un enorme elenco di metodi se, ad esempio, vuoi spostare il punto di esecuzione in un altro posto.
Sono ben informato sui lati negativi e positivi dei macro. -1 – liori
Sì, è possibile.
Individuare il file di pre-elaborato generato dal preprocessore nella cartella Debug.
Quindi, se la macro è scritto in testing.c file, il file pre-elaborato sarebbe chiamato testing.i
Ci si può vedere come la macro sono state ampliate.
Per eseguire il debug di esso, basta copiare e incollare questo codice al vostro :)
Se volete vedere il codice esteso generato dal preprocessore allora si può ottenere utilizzando il flag -E utilizzando gcc. Il comando sarà simile a questo:
$ gcc -E <source code> -o <preprocessed file name>
È possibile sostituire il codice sorgente originale utilizzando macro con il codice ampliato e posto qualunque punto di rottura che si desidera inserire lì.
Lo so, questo è quello che stavo facendo in quel momento. Ma la preelaborazione del compilatore Microsoft è leggermente diversa - per un esempio vedere http://social.msdn.microsoft.com/Forums/en-US/23f682bf-8421-474a-aa38-e32f9a0b728f/difference-between-microsoft-visual-studio -preprocessor-and-gcc; inoltre, volevo davvero non usare strumenti aggiuntivi, questo è un compito ingrato per presentarli a un'intera squadra. – liori
Ho imparato da http://www.codeproject.com/Tips/320721/Macro-expansion-in-VCplusplus il modo migliore per eseguire il debug delle macro.
E quello che faccio è quello di creare un file cxx denominato "test.cxx" e al suo interno ho messo solo la macro e alcuni usi esempio di test.cxx:
#define GetMacro(param1) \
public: void Get##param1(){ return m_##param1; }
GetMacro(MyVariable);
e in una riga di comando metto il:
c:\ cl /EP test.cxx > output.cxx
quando ho aperto il file output.cxx ci dovrebbero essere alcuni righe vuote e in fondo la macro espansa, come:
public: void GetMyVariable(){ return m_MyVariable; };
È possibile testare le macro senza compilare e questo è veloce.
ho sentito tutte le possibili risposte negative sul tema:
Sono tutti veri, ma IMO si scontrano con la realtà della programmazione di tutti i giorni.
In effetti, lavorando sul vecchio progetto C, in cui le macro venivano utilizzate principalmente come funzioni, questo divenne di cruciale importanza per me. La generazione di tutti i file preelaborati con/P funziona, ma è eccessiva e richiede molto tempo. Avevo solo bisogno di uno strumento che espanda una semplice macro definita con poche righe sopra o al massimo in altri file.
Come fare?
Quindi, sì, in un certo senso pratico, è possibile.
Se si utilizza Visual Studio per lavorare su progetti C o C++ che utilizzano macro, ottenere (credo che ci sia una versione di prova). Ti consente di fare clic su una macro ed espanderla completamente o in fasi. Abbiamo alcune macro nidificate estremamente complicate ed è l'unico modo per capirle.
Ho detto che le macro sono molto complicate? Mi piacerebbe espandere solo uno o due livelli, non tutte le macro (altrimenti è chiaramente illeggibile) ... durante il debug. – liori
Sì, fa schifo, ma non c'è una buona soluzione che io conosca. Di solito devo fare un po 'di hacking quando faccio questo, o manualmente sostituendo il codice me stesso solo per ottenere i livelli che voglio o per tutto il file tramite un file completamente preelaborato. –
@JimBuck Non riesco a trovare 'Genera file preelaborato' in Visual Studio 2013. – sami1592