Linee guida per migliorare il tuo codice

https://stackoverflow.com/questions/60673

09-06-2019
|

Domanda

Quali linee guida segui per migliorare la qualità generale del tuo codice?Molte persone hanno regole su come scrivere codice C++ che (presumibilmente) rendono più difficile commettere errori.Ho visto persone insistere che ogni if l'istruzione è seguita da un blocco di parentesi graffe ({...}).

Sono interessato a quali linee guida seguono le altre persone e le ragioni dietro di esse.Mi interessano anche le linee guida che ritieni siano spazzatura, ma che sono comunemente accettate.Qualcuno può suggerirne alcuni?

Per iniziare, ne citerò alcuni per cominciare:

Usa sempre l'apparecchio dopo ogni utilizzo if / else dichiarazione (menzionata sopra).La logica alla base di ciò è che non è sempre facile capire se una singola istruzione è effettivamente un'istruzione o una macro del preprocessore che si espande in più di un'istruzione, quindi questo codice si interromperebbe:

    // top of file:
    #define statement doSomething(); doSomethingElse

    // in implementation:
    if (somecondition)
        doSomething();

ma se usi le parentesi graffe, funzionerà come previsto.

Utilizzare le macro del preprocessore SOLO per la compilazione condizionale.le macro del preprocessore possono causare ogni sorta di inferno, poiché non consentono le regole di ambito C++.Mi sono incagliato molte volte a causa delle macro del preprocessore con nomi comuni nei file di intestazione.Se non stai attento puoi causare ogni sorta di caos!

Adesso tocca a te.

Soluzione

Alcuni dei miei preferiti personali:

Sforzati di scrivere il codice che sia const corretto.Utilizzerai il compilatore per aiutarti a eliminare bug facili da correggere ma a volte dolorosi.Il tuo codice racconterà anche una storia di ciò che avevi in mente nel momento in cui lo hai scritto: utile per i nuovi arrivati o per i manutentori una volta che te ne sarai andato.

Esci dal business della gestione della memoria.Impara a usare i puntatori intelligenti: std::auto_ptr, std::tr1::shared_ptr (O boost::shared_ptr) E boost::scoped_ptr.Scopri le differenze tra loro e quando usarne uno vs.un altro.

Probabilmente utilizzerai la libreria di modelli standard.Leggi il Il libro di Josutti.Non fermarti dopo i primi capitoli sui contenitori pensando di conoscere l'STL.Passa alle cose buone:algoritmi e oggetti funzione.

Altri suggerimenti

Elimina il codice non necessario.

Questo è tutto.

Utilizzare e applicare uno stile di codifica e linee guida comuni. Fondamento logico: Ogni sviluppatore del team o dell'azienda è in grado di leggere il codice senza distrazioni che possono verificarsi a causa di diversi stili di tutori o simili.
Esegui regolarmente una ricostruzione completa dell'intera base di origine (ad es.eseguire build giornaliere o build dopo ogni check-in) e segnalare eventuali errori! Fondamento logico: Il sorgente è quasi sempre in uno stato utilizzabile e i problemi vengono rilevati poco dopo essere stati "implementati", dove la risoluzione dei problemi è economica.

Attiva tutti gli avvisi che puoi visualizzare nel tuo compilatore (gcc: -Wall è un buon inizio ma non include tutto, quindi controlla i documenti) e commetti errori, quindi devi correggerli (gcc: -Werror).

La guida allo stile di Google, menzionata in una di queste risposte, è piuttosto solida.Ci sono alcune cose inutili dentro, ma è più buono che cattivo.

Sutter e Alexandrescu hanno scritto un buon libro su questo argomento, intitolato Standard di codifica C++.

Ecco alcuni suggerimenti generali da parte del piccolo me:

Il tuo rientro e lo stile tra parentesi sono entrambi sbagliati.Così sono quelli di tutti gli altri.Quindi segui gli standard del progetto per questo.Metti da parte il tuo orgoglio e imposta il tuo editor in modo che tutto sia il più coerente possibile con il resto della base di codice.È davvero fastidioso dover leggere il codice rientrato in modo incoerente.Detto questo, il bracketing e il rientro non hanno nulla a che fare con "migliorare il tuo codice". Si tratta più di migliorare la tua capacità di lavorare con gli altri.
Commenta bene.Questo è estremamente soggettivo, ma in generale è sempre bene scrivere commenti in merito Perché il codice funziona nel modo in cui funziona, invece di spiegare cosa fa.Naturalmente per il codice complesso è utile anche che i programmatori che potrebbero non avere familiarità con l'algoritmo o il codice ne abbiano un'idea Che cosa sta andando bene così.I collegamenti alle descrizioni degli algoritmi utilizzati sono molto graditi.
Esprimere la logica nel modo più semplice possibile.Ironicamente, suggerimenti come "mettere le costanti sul lato sinistro dei confronti" qui sono andati storti, credo.Sono molto popolari, ma per gli anglofoni spesso interrompono il flusso logico del programma per chi legge.Se non puoi fidarti di te stesso (o del tuo compilatore) per scrivere correttamente i confronti di uguaglianza, allora usa assolutamente trucchi come questo.Ma stai sacrificando la chiarezza quando lo fai.Rientrano in questa categoria anche cose come..."La mia logica ha 3 livelli di rientro?Potrebbe essere più semplice?" e inserendo codice simile in Functions.Magari anche suddividendo le funzioni.Ci vuole esperienza per scrivere codice che esprima elegantemente la logica sottostante, ma vale la pena lavorarci sopra.

Erano piuttosto generali.Per suggerimenti specifici non posso fare un lavoro migliore di Sutter e Alexandrescu.

Nelle istruzioni if metti la costante a sinistra, ad es.

if( 12 == var )

non

if( var == 12 )

Perché se ti perdi di digitare un '=' allora diventa un compito.Nella versione principale il compilatore dice che ciò non è possibile, nella seconda viene eseguito e l'if è sempre vero.

Utilizzo le parentesi graffe per gli if ogni volta che non sono sulla stessa riga.

if( a == b ) something();
if( b == d )
{
    bigLongStringOfStuffThatWontFitOnASingleLineNeatly();
}

Le parentesi graffe aperte e chiuse hanno sempre le proprie linee.Ma questa è ovviamente una convenzione personale.

Commenta solo quando è necessario solo spiegare cosa sta facendo il codice, laddove la lettura del codice non potrebbe dirti la stessa cosa.

Non commentare il codice che non utilizzi più.Se vuoi recuperare il vecchio codice, usa il tuo sistema di controllo del codice sorgente.Commentare il codice fa semplicemente sembrare le cose confuse e fa sì che i tuoi commenti che in realtà sono importanti svaniscano nel caos di sottofondo del codice commentato.

Utilizza una formattazione coerente.
Quando si lavora su codice legacy, utilizzare lo stile di formattazione esistente, specialmente.stile di tutore.
Ottieni una copia del libro di Scott Meyer Effective C++
Ottieni una copia del libro di Steve MConnell Code Complete.

C'è anche un bel Guida allo stile C++ utilizzato internamente da Google, che include la maggior parte delle regole qui menzionate.

Inizia a scrivere molti commenti, ma usalo come un'opportunità per rifattorizzare il codice in modo che sia autoesplicativo.

cioè:

for(int i=0; i<=arr.length; i++) {
  arr[i].conf() //confirm that every username doesn't contain invalid characters
}

Avrebbe dovuto essere qualcosa di più simile

for(int i=0; i<=activeusers.length; i++) {
  activeusers[i].UsernameStripInvalidChars()
}

Usa le schede per le rientranze, ma allinea i dati con gli spazi questo significa che le persone possono decidere quanto rientra modificando la dimensione della scheda, ma anche che le cose rimangono allineate (ad esempio, potresti voler tutto il '=' in una linea verticale quando assegna valori a a Struttura)
Utilizza sempre costanti o funzioni inline anziché macro, ove possibile
Non usare mai "using" nei file di intestazione, perché anche tutto ciò che include quell'heafer sarà interessato, anche se la persona che include l'intestazione non vuole tutto std (ad esempio) nel proprio spazio dei nomi globale.

Se qualcosa è più lungo di circa 80 colonne, suddividilo in più righe, ad es

if(SomeVeryLongVaribleName != LongFunction(AnotherVarible, AString) &&
   BigVaribleIsValid(SomeVeryLongVaribleName))
{
    DoSomething();
}

Sovraccaricare gli operatori solo per farli fare ciò che l'utente si aspetta, ad esempio sovraccaricare gli operatori + e - per un 2dVector va bene
Commenta sempre il tuo codice, anche se è solo per dire cosa sta facendo il blocco successivo (ad esempio "elimina tutte le texture che non sono necessarie per questo livello").Qualcuno potrebbe aver bisogno di lavorarci più tardi, possibilmente dopo che te ne sei andato e non vogliono trovare migliaia di righe di codice senza commenti per indicare cosa sta facendo cosa.

imposta la convenzione di codifica e fai in modo che tutti i soggetti coinvolti seguano la convenzione (non vorrai leggere codice che richieda di capire dove si trova l'istruzione/espressione successiva perché non è rientrata correttamente)
refactoring costante del codice (ottieni una copia di Refactoring, di Martin Fowler, i pro e i contro sono dettagliati nel libro)
scrivere codice liberamente accoppiato (evitare di scrivere commenti scrivendo codice autoesplicativo, il codice liberamente accoppiato tende ad essere più facile da gestire/adattare al cambiamento)
se possibile, prova l'unità del tuo codice (o se sei abbastanza macho, TDD.)
rilasciare presto, rilasciare spesso
evitare l'ottimizzazione prematura (la profilazione aiuta nell'ottimizzazione)

Allo stesso modo potresti trovare alcuni suggerimenti utili qui: Come si fa a far sembrare sbagliato il codice sbagliato?Quali modelli usi per evitare errori semantici?

Dove puoi, usa il pre-incremento invece del post-incremento.

Utilizzo PC-Lint nei miei progetti C++ e mi piace soprattutto il modo in cui fa riferimento a pubblicazioni esistenti come le linee guida MISRA o "Effective C++" e "More Effective C++" di Scott Meyers.Anche se hai intenzione di scrivere giustificazioni molto dettagliate per ogni regola controllata dal tuo strumento di analisi statica, è una buona idea indicare pubblicazioni consolidate di cui il tuo utente si fida.

Ecco il consiglio più importante che mi è stato dato da un guru del C++ e che mi ha aiutato in alcune occasioni critiche a trovare bug nel mio codice:

Utilizzare i metodi const quando un metodo lo è Non dovrebbe per modificare l'oggetto.
Utilizzare riferimenti e puntatori const nei parametri quando l'oggetto è Non dovrebbe per modificare l'oggetto.

Con queste 2 regole, il compilatore ti dirà gratuitamente dove nel tuo codice la logica è difettosa!

Inoltre, per alcune buone tecniche che potresti seguire Il blog di Google "Test sul WC".

Guardatelo sei mesi dopo

assicurati di rientrare correttamente

Hmm, probabilmente avrei dovuto essere un po' più specifico.

Non cerco tanto consigli per me stesso: sto scrivendo uno strumento statico di analisi del codice (le attuali offerte commerciali semplicemente non sono abbastanza buone per quello che voglio), e sto cercando idee per i plugin per evidenziare possibili errori nel codice.

Diverse persone hanno menzionato cose come la correttezza costante e l'utilizzo di puntatori intelligenti: questo è il tipo di pensiero che posso verificare.Controllare il rientro e i commenti è un po' più difficile da fare (almeno dal punto di vista della programmazione).

I puntatori intelligenti hanno un modo carino di indicare la proprietà in modo molto chiaro.Se sei una classe o una funzione:

se ottieni un puntatore grezzo, non possiedi nulla.Puoi usare la punta, per gentile concessione di chi ti chiama, che garantisce che la punta rimarrà in vita più a lungo di te.
se ottieni un debole_ptr, non possiedi la punta e per di più la punta può scomparire in qualsiasi momento.
se ottieni un condiviso_ptr, possiedi l'oggetto insieme ad altri, quindi non devi preoccuparti.Meno stress, ma anche meno controllo.
se ottieni un auto_ptr, sei l'unico proprietario dell'oggetto.È tuo, tu sei il re.Hai il potere di distruggere quell'oggetto o di darlo a qualcun altro (perdendone così la proprietà).

Trovo che il caso di auto_ptr sia particolarmente forte:in un progetto, se vedo un auto_ptr, so immediatamente che quell'oggetto "vagherà" da una parte all'altra del sistema.

Questa è almeno la logica che utilizzo nel mio progetto preferito.Non sono sicuro di quante variazioni possano esserci sull'argomento, ma fino ad ora queste regole mi sono state utili.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow