Quale è meglio, un commento dettagliato centrale o diversi più piccoli?

4

Per riformulare la domanda: quale è meglio, un commento centrale dettagliato o più piccoli "spruzzi"?

Resta con me mentre preparo la scena:

Ho questa funzione per prelevare un valore da un'implementazione di coda:

int queue_pop(queue *list, void **pValue);

Se hai familiarità con C, comprendi che chiamare questa funzione in questo modo:

struct foo *pFoo;
int rc;
rc = queue_pop(g_FooList, &pFoo);

ottieni questo:

gcc: warning-incompatible pointer type passing 'foo **' to parameter of type 'void **'

Ora, come capita, chiamare questa funzione in questo modo è perfettamente sicuro; la funzione non si rivolge mai al puntatore dereferenziato come qualcosa di diverso da un vuoto *, e l'allocazione e la copia della memoria viene eseguita in base rigorosamente alla dimensione dell'elemento, che è definita in ogni coda data. Ma, per evitare gli avvertimenti, lo chiamo in questo modo:

rc = queue_pop(g_FooList, (void**)&pFoo);

che non è strettamente portatile in C, ma anche in questo caso è perfettamente sicuro. Ma poiché gli argomenti della funzione di cast non sono quasi mai necessari in C, ed è in effetti quasi SEMPRE a coprire un errore, documento la prima chiamata di questo tipo in ogni funzione come questa:

/* Explicit cast - see comments on queue_pop function in queue.c */
rc = queue_pop(g_FooList, (void**)&pFoo);

In questo modo, chiunque legga il codice può aprire il file queue.c e leggere una spiegazione dettagliata del perché questo è OK, e non preoccuparsi di ciò. E poiché non lo faranno, almeno sanno che è stato fatto apposta, e c'è una ragione.

La domanda sorge perché somone mi ha suggerito di liberarmi del cast - dal momento che è così insolito - e di chiamare semplicemente la funzione con il tipo di puntatore concreto. Quindi sopprimete l'avviso con una #pragma push nella parte superiore del file sorgente e inserite un commento dettagliato sul pragma che spiega la soppressione. Dato che alla fine il codebase sarà open source e i commenti del codice sorgente (rispetto ai commenti del file di intestazione) avranno quindi un pubblico più ampio del normale, sarà più organizzato in questo modo.

A parte il fatto che non sono un grande fan di sopprimere gli avvertimenti in primo luogo (ad eccezione di alcuni dei più sciatti di MSVC), è stata la mia esperienza che:

  • A) le persone non leggeranno
  • B) se vuoi che qualcuno legga qualcosa, è meglio che lo attacchi proprio davanti ai loro occhi
  • C) vedi A

Ora, il tag comments dice che è per domande su "Best Practices", ma mi rendo conto che questo potrebbe tendere un po 'troppo verso "opiniony". Se è così, appendi solo alcuni downvotes e cancellerò la domanda.

EDIT Ho visto questa domanda , ma sembra un mosh generale sull'opportunità o meno di usare i commenti. Non è questo il problema qui: userò sicuramente una sorta di commento.

    
posta Mark Benningfield 14.12.2017 - 08:58
fonte

4 risposte

1

Come nodo laterale, puoi definire una macro:

    /* pop_macro is used to avoid the incompatible type compiler warning */ 
    #define pop_macro(FooList,Foo) queue_pop(FooList, (void**)Foo)

Al contrario di:

    queue_pop(g_FooList, (void**)&pFoo)

sarebbe come:

    pop_macro(g_FooList, &pFoo)

e l'avviso del compilatore scompare e c'è un punto singolo per fare un commento che altre persone possono trovare.

    
risposta data 15.12.2017 - 21:01
fonte
3

La risposta è: qualunque dei tuoi colleghi programmatori leggerà .

In generale:

I commenti spruzzati saranno letti di più perché gli esseri umani hanno una scarsa attenzione e un commento su una linea che stiamo già leggendo tende a farsi notare. Raramente (se mai) cercheremo un commento, ma potremmo semplicemente notarlo quando è richiesto. Lo leggeremo solo se sappiamo già che esiste e se è non troppo difficile da trovare .

L'ora principale in cui un commento centrale verrà letto è durante una revisione del codice. Questo può essere molto utile, in quanto può rendere la revisione di una particolare modifica / diramazione / funzione più semplice e più diretta. Puoi quindi fare riferimento a quel commento centrale in tutto il codice, eseguendo il backup degli sprinkles.

Anche gli standard che hai impostato, come le spiegazioni delle funzioni nei file di intestazione, possono essere previsti / desiderati dai tuoi colleghi programmatori, se ci sono abituati.

Alla fine, la maggior parte dei programmatori non leggerà ogni commento , specialmente nel mondo open-source, dove quasi certamente non hanno avuto il tempo di leggere la documentazione o di sfogliare l'intero code-base prima immersioni. È meglio avere le informazioni proprio di fronte a te , anche se si tratta di un breve riferimento a una spiegazione più ampia, almeno allora sai che c'è una spiegazione e questo non era t un errore .

Più specificamente per il tuo esempio:

Se puoi risolvere un avvertimento / errore del compilatore con il codice, dovresti farlo. Spiega come lo stai facendo, ma risolvilo nel codice non con le impostazioni del compilatore. Qualcuno potrebbe voler collegare un altro compilatore un giorno e avere tutto il tuo #pragma potrebbe essere una perdita di tempo. In questo modo, un breve commento è una cosa meravigliosa.

    
risposta data 14.12.2017 - 10:24
fonte
2

Uno svantaggio di avere un commento di codice ogni volta che lo chiami è che ci sono così tanti commenti che l'utente inizierà a ignorarli. Prendi in considerazione la creazione di una funzione che chiami come my_queue_pop(g_FooList, &pFoo); e che quindi chiama queue_pop(g_FooList, (void**)&pFoo); . Quindi inserisci il commento all'interno della definizione di my_queue_pop . In questo modo il lettore capirà semplicemente guardando il nome della funzione.

    
risposta data 14.12.2017 - 18:55
fonte
1

La risposta accettata praticamente coincide con il mio approccio iniziale. Mi viene in mente che poiché questo è destinato ad essere un codice di codice open source, che presumibilmente sarà costruito dalla fonte secondo necessità, potrei prendere il consiglio di @Robert Harvey e lasciare l'avviso, e lasciare che l'utente si preoccupi di esso se si preoccupa loro tanto.

Per quanto io sia tentato di fare proprio questo, so che finirà per essere un boomerang. Come indicato nella risposta accettata, non esamineranno il problema e vedranno che l'avviso è spurio, ma si limiteranno a presentare un ticket di emissione. Non guarderanno l'avviso nella documentazione del progetto in modo che l'avvertimento non si applichi: si limiteranno a presentare un ticket di emissione.

E poiché probabilmente non leggeranno comunque il codice sorgente, i pochi commenti su una riga cosparsi attorno al cast del puntatore non solleveranno alcun trucco, perché non verranno visti.

Quindi, nota a te stesso: realisticamente, non ci saranno molti bulbi oculari sul codice sorgente, quindi non anticipare il dolore dove è improbabile che si verifichi.

Modifica Mentre continuo a pensare che questa sia una posizione completamente sostenibile, ho dovuto cambiare la risposta accettata perché qualcuno in realtà ha risolto il problema.

Definendo la macro suggerita direttamente nell'implementazione della coda, l'incertezza viene risolta all'origine e spiegata al punto di risoluzione.

    
risposta data 15.12.2017 - 17:14
fonte

Leggi altre domande sui tag