Perché usare #if 0 per blocco di commento?

Reverse engineering del codice e io sono un po ‘ sconcertati per lo stile, ma ho voluto assicurarsi che non c’è nessun buon motivo per fare queste cose….

È solo a me o è un orribile stile di codifica

if ( pwbuf ) sprintf(username,"%s",pwbuf->pw_name);
else sprintf(username,"%d",user_id);

E perché avvolgere il codice non è inteso per la compilazione in un

#if 0
....
#endif

Invece dei commenti?


EDIT: Così come alcuni spiegato di seguito, questo è dovuto alla possibilità di flummox /* */che non ho capito.

Ma non ho ancora capito, perchè non usare il vostro ambiente di programmazione o di strumenti di editor di testo preferito macro di bloccare commento è fuori con “//”

non sarebbe MOLTO più semplice e facile conoscere a ignorare?


Mi sono proprio inesperto in C e manca il perché di queste cose potrebbe essere una buona idea, o c’è nessuna scusa, e io sono giustificato a sentirsi irritato per come è brutto questo codice?

  • L’ho già fatto prima, per qualche motivo sembra più chiaro. Mai visto le direttive del preprocessore per commentare il codice di fuori.
  • Ho visto che l’uso di direttive del preprocessore un sacco 😀
  • È un po ‘ brutto, ma non al massimo fugly. Si ha la possibilità di guardare molto meglio con solo la luce a moderato di birra occhiali.
  • Ho fatto che la direttiva del preprocessore cosa. Il vantaggio è che non mantiene la formattazione del codice e il colore di codifica. È anche più facile per ruotare il blocco di codice di commenti.
  • Indossando il mio burbero vecchio, brutto tipo di cappello per un momento, si deve ricordare che una discreta quantità di C idioma (tra cui #if 0) risale ai primi giorni. Abbiamo usato i morsetti con un numero limitato di caratteri totali, non di grafica, non di windows, e solo il colore del testo, perché il CRT era solo uno di fosforo. Redattori in grado sufficiente per fare blocco di commentare in modo intelligente reale scarse.
  • Inoltre, riduce al minimo le differenze e rende patch infinitamente più facile da leggere.

InformationsquelleAutor Jason R. Mick | 2010-09-02



11 Replies
  1. 36

    #if 0 è usato abbastanza frequentemente quando rimosso il blocco che contiene il blocco-commenti

    Io non dico che è una buona pratica, ma la vedo piuttosto spesso.

    La singola linea di flusso-controllo+istruzione è abbastanza facile da capire, anche se io personalmente evitarlo (e la maggior parte delle linee guida di codifica ho lavorato sotto lo vieta)

    BTW, probabilmente sarei modificare il titolo per essere un po ‘ utile “Perché #if 0 invece di bloccare i commenti”

    Se si hanno i seguenti

    #if 0
            silly();
            if(foo)
               bar();
            /* baz is a flumuxiation */
            baz = fib+3;
    #endif

    Se ingenuamente sostituire il #if 0/#endif con /* */, che causa il commento a fine destra dopo flumuxiation, causando un errore di sintassi quando si colpisce la */ al posto del #endif sopra..

    EDIT: Una nota finale, spesso il #if 0 sintassi è solo utilizzato durante lo sviluppo, in particolare se si ha il supporto di più versioni o dipendenze o piattaforme hardware. Non è insolito che il codice deve essere modificato

    #ifdef _COMPILED_WITHOUT_FEATURE_BAZ_
        much_code();
    #endif

    Con una gestione centralizzata di intestazione definizione (o non) le centinaia di #define costanti. Non è la cosa più bella del mondo, ma ogni volta che ho lavorato su un dignitoso dimensioni del progetto abbiamo utilizzato una combinazione di runtime switch di compilazione costanti di tempo (questo), compilazione compilazione decisioni (basta usare diversi .cpp a seconda della versione), e l’occasionale soluzione di modello. Tutto dipende dai dettagli.

    Mentre sei lo sviluppatore di ottenere la cosa che lavorano in primo luogo, anche se… #if 0 è abbastanza comune, se non siete sicuri se il vecchio codice, ha ancora un valore.

    • Perché non basta usare il buon vecchio moda /* */ ??? non è MOLTO più chiara che il codice non è MAI sta per essere compilato durante la visualizzazione in un editor di testo/codice env.? Sembra che si potrebbe facilmente perdere il preprocessore tag, quando la scansione il codice e pensare che era in fase di compilazione.
    • Un discreto editor grigio #if 0 piacerebbe codice, in modo che non è tanto di un problema. L’Editing con un esempio.
    • emacs non è un editor decente? Voglio dire che colora il resto della mia c-testo… e si colora commentato il codice…
    • Non è possibile utilizzare /**/ per commentare altri /**/, non nido.
    • Se si tratta di un sacco di codice, non è sempre facile vedere dove il blocco di commento si conclude. Ma soprattutto penso che sia una tradizione dai tempi in cui i compilatori avuto problemi con i commenti nidificati.
    • <insert battuta su un sistema operativo decente editor qui>. Boh… vim, SlickEdit e Visual Studio tutti interpet #if 0 come un delimitatore di commento. Considerando la complessità di configurazione di emacs e vim, però, ho il sospetto che c’è un pulsante o manopola è bisogno di girare.
    • Come jkerian sottolineato, se il codice che si sta commentando già ha un blocco preventivo, poi aggiungere un altro set di citazioni di blocco non funziona. Utilizzando #se 0 è un modo molto migliore di farlo.
    • perché /* */ commenti per nidificare. Quindi, se li si usa per nascondere il codice, che in sé contiene un commento, il (esterno) commento finale al primo */.
    • …ma ancora, perché non utilizzare // per blocco di commento. Che avrebbe funzionato, giusto? In emacs tutto ciò che dovrete fare è definire una macro e poi chiamare un paio di volte con ctrl+u <# tempi> ctrl+x e … non sarebbe più chiaro da leggere e sapere che è stato commentato? (si potrebbe utilizzare una inversione macro per scopi simili…)
    • Mentre questo è fattibile nella maggior parte dei redattori, vi suggerisco di riflettere sul fatto che “/* */” sono “i commenti di blocco” e // indica una “riga di commento. il #if 0 meccanismo funziona in modo molto simile al blocco di commenti, e fa un certo senso che sarebbe preferito.
    • Perché // non è (o era) un ufficiale di C, il commento è arrivato con il C++ — alcuni compilatori ammessi doppio slash commenti e alcuni non. Non so che cosa l’ultimo C standard dice su questo argomento.
    • non è un valido C89 istruzione, è necessario utilizzare C99 o C++
    • hmm interessante. Così sono stati solo /* */ permesso? Come hai fatto a commento sotto il vecchio spec?
    • …e in quel caso, potrebbe essere proprio la soluzione migliore sia usare una macro per inserire #if 0 all’inizio della linea e #endif alla fine della linea? … sarebbe più chiaro allora che parte è stato scanalato per la rimozione dalla compilazione IMO
    • Le direttive per il preprocessore di essere all’inizio di linee, quindi non si può commentare una singola riga con #if 0 / #endif
    • Si può avere qualcosa di simile # define anche se, credo.
    • Inoltre, nessuno editor con il grigio il codice. Codice Gray è più difficile da leggere rispetto sintassi colorata codice. Non mi importa se sto usando, non dovrei essere in grado di vedere!
    • grigio, segno di come il blu scuro (la mia preferenza), o quant’altro… ha commentato il codice deve essere chiaro che non è in uso. Fare #if 0d codice facile perdere è un terribile idea. Bella l’evidenziazione della sintassi dei miei tipi è del tutto secondario il fatto che questo codice NON VERRÀ ESEGUITO.
    • Quindi, se io commento un blocco di codice per un motivo o per un altro, si dovrebbe ancora essere colorato come se fosse in esecuzione? Tra le altre cose, che renderebbe ricerca di tag di commento di un incubo

  2. 18

    Commenti sono commenti. Essi descrivono il codice.

    Codice che viene esclusi dalla compilazione del codice, non commenti. Spesso includono commenti, che descrivono il codice non viene compilato, per il momento/

    Sono due concetti distinti, e costringendo la stessa sintassi mi sembra essere un errore.

    • +1 Questa è una buona razionalizzazione. Fate un buon argomento per il sempre tramite il preprocessore per escludere codice. Certo è un po ‘ brutto, ma è morto il codice dovrebbe essere brutto, giusto?
    • Si potrebbe fare il punto che commentando il codice che non è usata (non importa se è fatto con i commenti o le direttive del preprocessore) è un abuso, perché quello è il compito di un SCM. Nel caso In cui si desidera conservare una vecchia versione di una pace di codice (ad esempio per evitare di fare un errore due volte) questo codice sicuramente diventa statico commento (codice mescolato con spiegazioni utili) che non ha più nulla a che fare con il codice del tuo programma. Tale dato potrebbe essere sempre sbagliato escludere codice di compilazione.
    • Non dico sempre, ma in generale, sono d’accordo con te. Penso che la corretta pratica sarebbe per pulire questo tipo di mess prima del check-in.
  3. 6

    Oltre al problema con il C stile di commenti non nidificazione, la disattivazione di blocchi di codice con #if 0 ha il vantaggio di essere in grado di essere crollato se si utilizza un editor che supporta code folding. È anche molto facile da fare in un qualsiasi editor, mentre la disattivazione di grandi blocchi di codice con stile C++commenti possono essere pesanti senza il supporto di editor/macro.

    Inoltre, molti #if 0 i blocchi hanno un else blocco. Questo dà un modo semplice per scambiare tra due implementazioni di algoritmi, e, probabilmente, è meno soggetto a errori di massa-commentando una sezione e di massa di eliminare il commento di un altro. Tuttavia, sarebbe meglio usare qualcosa di più leggibile, come #if DEBUG in questo caso.

  4. 3

    Che è abbastanza idiomatiche C a destra c’. Non vedo cosa c’è di così sbagliato con esso. Non è un bel pezzo di codice, ma è di facile lettura ed è chiaro cosa sta succedendo e perché, anche senza contesto.

    I nomi delle variabili potrebbe essere migliore, e probabilmente sarei più sicuro usare snprintf o forse strncpy.

    Se si pensa che potrebbe essere meglio, che cosa si preferisce apparire come?

    Potrei fare una lieve modifica:

    char username[32];
    strncpy(username, 30, (pwbuf ? pwbuf->pw_name : user_id));
    username[31] = '\0';
    • Credo che preferirei vedere l’altro la logica di mettere su una riga successiva. Voglio dire, capito ciò che si sta facendo, ma quando vedo “altro” e poi quello che sembra un condizionale, il mio cervello un pò si scioglie. Solo che mi dà fastidio per qualche motivo. Di nuovo, forse non è logico, è per questo che ho posto la domanda… Forse io sono di riqualificare il mio cervello a pensare che sia una buona idea?
  5. 3

    Quanto riguarda il blocco commentando usando il // è interessato, un motivo che posso pensare è che si deve controllare che il codice nell’origine del sistema di controllo, la colpa registro di mostrare come l’ultimo editor per quelle linee di codice. Mentre probabilmente si desidera che i commenti per essere attribuito, allo stesso tempo, il codice viene anche attribuita. Certo, si può andare indietro e guardare le revisioni precedenti se avete bisogno di controllare la colpa di registro per il “vero” autore del codice, ma si farebbe risparmiare tempo se conservato che informazioni nella revisione corrente.

    • Buon punto, ma, allo stesso tempo, se si utilizza il controllo di origine, probabilmente non dovrebbe essere commentando codice morto. Probabilmente si dovrebbe essere l’eliminazione.
  6. 1

    Ovviamente, ognuno ha le proprie opinioni su questo genere di cose. Quindi, ecco la mia:

    Vorrei mai scrivere il codice come sopra, e potrebbe pensare di meno di chi ha fatto. Non riesco a contare il numero di volte che la gente pensa che è ok per allontanarsi senza ambito parentesi graffe, e poi è stato morso da esso.

    Mettere il controllo economico sulla stessa linea come il blocco di codice che è anche peggio; la mancanza di rientro rende più difficile vedere il flusso di controllo durante la lettura. Una volta che codifica per un paio di anni, ci si abitua a essere in grado di leggere e interpretare il codice rapidamente e con precisione, così a lungo come si può contare su alcuni spunti visivi. Per aggirare questi spunti per “casi particolari” significa che il lettore deve fermarsi e fare un doppio prendere, per nessuna buona ragione.

    #if (0), invece, è ok in fase di sviluppo, ma deve essere rimosso una volta che il codice è “stabile” (o almeno sostituire 0 con alcune significative simbolo del preprocessore nome).

    • Quando ho codificato utilizzando principalmente vi in esecuzione su un 80 colonna 25 linea VT-100 clone terminale composto fino a 2400 baud per BSD su VAX, ogni riga della schermata è stata preziosa, così if (a) b(); else c(); è molto più accettabile per me che di rottura che in quattro linee, e l’abitudine di passare le parentesi graffe alle proprie linee è stato effettivamente impensabile. Oggi, sono più inclini a essere generosi con il verticale lo spazio bianco. Devi avere vissuto entro i limiti di un vero e proprio terminale ad apprezzare i benefici del terser stile, ho il sospetto.
    • Io continuo a scrivere il codice come l’esempio di oggi, solo se si adatta completamente su una sola riga. Il momento si piega di più, ha bisogno di parentesi graffe per evitare i rischi evidenti. Su una linea, c’è meno tentazione di accidentalmente modificare extra bilancio.
    • Credo significativo simbolo del preprocessore nomi sono ok, purché esplicitamente #undef piacerebbe. Il problema con le cose come #ifdef NOT_THIS è che uno deve cercare attraverso tutti i file inclusi per vedere se NOT_THIS è definito. Se trovare un #undef NOT_THIS, si dispone di una risposta. Se non, si è lasciato chiedendo: “ho cercato in tutti i file?”. Non ci sono problemi di questo tipo con #if 0.
    • No. Non sostituire mai l’0 #se 0 con un altro. Perché a qualcuno potrebbe venire insieme e definire la macro e inavvertitamente includere il codice. Che cosa si dovrebbe fare è eliminare il #if 0 bloccare del tutto, e di fare affidamento sul sistema di controllo di versione, invece.
    • Io non credo che ci sia molto di un problema con le cose come #if (DEBUG_MODE) o #if (DISPLAY_GRAPHS), etc. per le cose che può ancora essere utile per accendere o spegnere. Tuttavia, per la sperimentazione di codice che dovrebbe non essere più necessario, sono d’accordo, eliminarlo.
    • Charlesworth: sono totalmente d’accordo. compilazione condizionale fro eseguire il debug e per comprendere caratteristiche specifiche non è un problema. È solo il commento di obsoleti il codice che io le abbia problema con.

  7. 0

    Woah c’è!!! Non esagerare…

    Io la chiamerei sloppier più incoerente spaziatura di qualsiasi altra cosa. Ho avuto il tempo in cui l’ho trovato di meglio per mettere brevi istruzioni sulla stessa riga, come SE, anche se tali dichiarazioni sono stretching.

    Lo stile inline è meglio verticali per brevità… potrebbe essere facilmente suddiviso in 4, più linee

    if (pwbuf) 
      sprintf(username,"%s",pwbuf->pw_name); 
    else 
      sprintf(username,"%d",user_id); 

    Personalmente odio lo stile successivo, poiché così prolisso, rendendo difficile per scremare un file.

    if (pwbuf) 
    {
      sprintf(username,"%s",pwbuf->pw_name); 
    }
    else
    { 
      sprintf(username,"%d",user_id); 
    }
    • La ragione per le staffe extra sono da preferire è quello di evitare che qualcuno l’aggiunta di un extra di linea in un secondo momento e di pensare di far parte di una clausola originaria.
    • le staffe sono molto più a prova di futuro.
    • Se goto fail insegnato qualcosa … stackoverflow.com/questions/21999473/… avevo messo le parentesi graffe sulla stessa linea if e else (tranne l’ultimo) per ridurre il numero delle righe.
    • Che cosa circa #if 0/#if 1 dichiarazioni?
  8. 0

    punti sopra indicato. Ma controlla di essere widescreen e tutti, in questi giorni, ho cercato di non mente

    if (pwbuf) sprintf(username,"%s",pwbuf->pw_name);
    else       sprintf(username,"%d",user_id);

    Sembra sempre di avere troppo spazio orizzontale, e non abbastanza spazio in verticale sul mio schermo!

    Inoltre, se il blocco di codice che ha già le direttive del preprocessore, non utilizzare #if 0; se il codice ha già i commenti di blocco, non utilizzare /* */. Se si dispone già di entrambe, ricorrere ad un editor che ha un ctrl+/, per commentare un sacco di linee. Se non sei fregato, eliminare il codice definitivo di!

    • C pedanteria avviso: // sono C++ commenti…
    • Il C Standard (WG14 N1124 – ISO/IEC 9899:1999; 6.4.9): “ad Eccezione all’interno di un carattere costante, un valore letterale di stringa, o un commento, i caratteri // introdurre un commento che include tutti i caratteri multibyte fino a, ma non compresi, il prossimo carattere nuova riga.”
    • Che C99. // non è parte di C89 o C90, anche se la maggior parte dei compilatori di accettare.
    • Il preprocessore blocco di codice di disattivazione (non è proprio un commento) fa il nido.
    • Come nmichaels detto, il preprocessore se blocchi nido. Il preprocessore #if blocchi devono essere documentate con /* */ commenti (o // commenti se preferite, e hanno un C99-compatibile compilatore, ma che si può buttare la gente fuori) per chiarezza comunque, quindi #if 0 blocchi non dovrebbero rendere le cose meno leggibile se sono adeguatamente commentato.
  9. 0
    if ( pwbuf ) sprintf(username,"%s",pwbuf->pw_name);
    else sprintf(username,"%d",user_id);

    Idiomatiche e conciso. Se si fosse toccato più di 2 o 3 volte, mi piacerebbe staffa e della prossima linea. Non è molto gestibile se si aggiungono le informazioni di registrazione o di altre condizioni.

    #if 0
    ....
    #endif

    Buona per attivare i blocchi di codice di debug o non. Inoltre, permetterebbe di evitare errori di compilazione relative al tentativo di blocco di commento questa sorta di cosa:

    /* line comment */
    ...
    /* line comment again */

    Dal C blocco di commenti non nido.

  10. 0

    Molto occasionalmente uso più conciso di stile quando si supporta la simmetria del codice e le linee non sono troppo lunghi. Prendiamo il seguente esempio artificioso:

    if (strcmp(s, "foo") == 0)
    {
        bitmap = 0x00000001UL;
        bit = 0;
    }
    else if (strcmp(s, "bar") == 0)
    {
        bitmap = 0x00000002UL;
        bit = 1;
    }
    else if (strcmp(s, "baz") == 0)
    {
        bitmap = 0x00000003UL;
        bit = 2;
    }
    else if (strcmp(s, "qux") == 0)
    {
        bitmap = 0x00000008UL;
        bit = 3;
    }
    else
    {
        bitmap = 0;
        bit = -1;
    }

    e la versione sintetica:

    if      (strcmp(s, "foo") == 0) { bitmap = 0x00000001UL; bit = 0;  }
    else if (strcmp(s, "bar") == 0) { bitmap = 0x00000002UL; bit = 1;  }
    else if (strcmp(s, "baz") == 0) { bitmap = 0x00000003UL; bit = 2;  }
    else if (strcmp(s, "qux") == 0) { bitmap = 0x00000008UL; bit = 3;  }
    else                            { bitmap = 0;            bit = -1; }

    Bug sono molto più propensi a saltare dritto in faccia.

    Disclaimer: Questo esempio è improbabile, come ho detto. Sentitevi liberi di discutere l’uso di strcmp, numeri di magia e se una tabella basata approccio sarebbe meglio. 😉

  11. -1

    #if 0 ... #endif è abbastanza comune nei vecchi C codice. Il motivo è che commentare con commenti in stile C /* .... */ non funziona perché i commenti non nido.

    Anche se è comune, direi che non ha alcun posto nel codice moderno. Persone lo ha fatto nei giorni olden, perché il loro editor di testo non riusciva a bloccare commento ampie sezioni automaticamente. Più pertinentemente, non hanno corretto il controllo del codice sorgente come facciamo ora. Non ci sono scuse per lasciare commentato o #ifdef in codice di produzione.

Lascia un commento