Come sei diventato un convertito di correttezza const? [chiuso]

Dopo 15 anni di C ++, non ho ancora imparato ad amare usando const. Capisco che è utile, ma in realtà non sono mai stato in una situazione in cui essere corretti avrebbe evitato il problema che stavo affrontando.

Quindi, come hai imparato ad amare i benefici dei cons?

Beh, non ero convinto finché non ho provato ad abbracciare la filosofia.

Ho iniziato per la prima volta ponendo constai membri di sola lettura dei membri della mia classe di base e argomenti relativi alle funzioni dei membri.

Da lì, non ho più potuto compilare. Quindi ho perseverato ad entrare nel codice usando quelle classi di base, per vedere se le constaggiunte precedenti erano davvero legittime rispetto all'uso che ne facevo. Mi ha aiutato a correggere alcuni bug sulla strada mentre aggiungevo costanza ad altre parti del codice.

È contagioso. La maggior parte del codice ha ottenuto ancora più costanza e ho trovato più facile eseguirne il debug perché ti rende sicuro che il compilatore ti fermerà se inizi a modificare qualcosa che non dovresti.

Una volta riavviata l'applicazione, è stato più veloce (ho dovuto modificare alcuni algoritmi che ho scoperto non erano adatti al lavoro), con molti meno bug e più facili da capire durante la lettura del codice.

Ero convinto.

Ora, penso che sia ancora meglio quando stai usando molte asserzioni oltre alla costanza perché ti fa sentire sicuro quando devi scrivere un nuovo codice o modificare il codice corrente. Sai che il compilatore ti fermerà se necessario. Ti consente di dimenticare di dover controllare tutto ciò che non dovresti modificare e quindi hai più tempo per pensare per il pensiero più specifico per il business o il pensiero architettonico.

Non sono mai stato un sostenitore della programmazione orientata agli oggetti, e semmai sono cresciuto di meno, tanto più imparo sulla programmazione in generale. Come ho studiato diversi paradigmi di programmazione, ho capito che l'immutabilità è uno dei concetti centrali del programma di progettazione, che colpisce software scritto in base alle qualsiasi filosofia. È estremamente importante nella programmazione funzionale, con implicazioni in termini di ottimizzazione e concorrenza oltre alle semplici garanzie di sicurezza.

Fondamentalmente, tutto ciò che può essere immutabile probabilmente dovrebbe essere, a meno che tu non abbia una buona ragione per lo stato mutevole. Nella mia esperienza, scrivere programmi in qualsiasi lingua per raggiungere questo obiettivo porta a un codice più sicuro e migliore . Non hai nulla da perdere usando constdove applicabile: l'immutabilità è gratuita!

(Per inciso, ho giocato con l'idea di creare un fork di GCC per un dialetto di C ++ in cui tutti i tipi sono constesplicitamente qualificati come mutable. Se c'è supporto per una cosa del genere, mi impegnerò totalmente a mantenerla e usarla.)

Da un punto di vista OO, l'immutabilità impone l'incapsulamento impedendo l'accesso in scrittura senza restrizioni. Riduce l'accoppiamento tra le classi perché gli oggetti immutabili devono gestire completamente il proprio stato e comportarsi quindi come valori ordinari. La correttezza costante facilita in modo significativo il processo di dimostrazione della correttezza del programma, soprattutto nel contesto della programmazione concorrente. Con la semantica di riferimento C ++ e C ++ 0x rvalue, è possibile utilizzare oggetti immutabili senza preoccuparsi del sovraccarico di copiarli ovunque. Inoltre, il compilatore può funzionare con un'incredibile magia di ottimizzazione se lavori con oggetti per lo più immutabili.

So che fa schifo digitare constovunque, ma ci si abitua rapidamente e i vantaggi diventano evidenti nel tempo in termini di affidabilità e manutenibilità. Non sono uno scrittore brillante, e sembra essere un compito difficile dimostrarlo, ma so che la correttezza const è stata immensamente utile per me come sviluppatore durante la progettazione e l'implementazione di programmi, e penso che l'esperienza sia il miglior insegnante in questo senso.

Il vantaggio della const const è che impone una disciplina al programma e rende più facile ragionare su parti del programma.

La disciplina è che devi sapere dove qualcosa potrebbe essere cambiato. Il vantaggio corrispondente è che è più facile vedere cosa fa un pezzo di codice quando si può dire cosa potrebbe cambiare lo stato.

Essere costantemente corretti enfatizza la correttezza del progetto che tratto vicino a un problema simile che non utilizza operatori del cast; quindi non usare il cast ed essere costanti, un utilizzo minimo del mutevole - tutti questi sono indicatori per misurare quanto è buono il design ma non gli strumenti reali per risolvere il problema generale in mano.

PS: mi sono completamente convinto di constaver capito la correttezza nell'usarlo;)

Vedo due motivi principali per scrivere codice const-correct. Uno è che il compilatore è tuo amico e, usando const, ti consente di avvisarti di potenziali bug. Il secondo motivo è che la correttezza const rende il codice più leggibile. Ad esempio, sai sempre quali argomenti della funzione sono input e quali output. Sai anche quali funzioni membro modificano l'oggetto e quali no. Sai queste cose all'istante senza dover leggere il codice. Questo, ovviamente, presuppone un uso molto giudizioso di const_cast.

Sono stato convertito non appena ho saputo che era possibile. Per me aveva senso dal punto di vista del "buon stile di programmazione". Esistono vari motivi per cui è buona norma essere corretti:

• Leggibilità e comprensione. Se sto leggendo il codice di qualcun altro e una funzione accetta un riferimento const come parametro, so che il parametro deve essere utilizzato solo come variabile di sola lettura. Questa è una vittoria enorme soprattutto se il codice è un ambiente multi-thread.
• Il compilatore può utilizzare il qualificatore const per facilitare i passaggi di ottimizzazione.
• Supponiamo di avere un oggetto di classe A in una situazione in cui non voglio che cambi. Quindi le uniche funzioni membro che possono essere chiamate per quell'oggetto sono quelle che sono const.

Per riassumere due punti che sono stati trattati in altre risposte e aggiungerne uno nuovo:

• constdocumenta il codice per gli utenti della tua API. Forma un contratto tra una funzione e il suo chiamante, che la funzione non modificherà i suoi parametri. (Si noti che const_castnon consente a una funzione di modificare il suo parametro, ma consente di passare quel parametro ad altre funzioni che non modificano i loro parametri ma hanno dimenticato l' constannotazione.) È utile anche all'interno di funzioni / loop / ecc. Perché aiuta a comprendere molto allo stesso modo di un invariante di loop.

• constdocumenta le tue intenzioni al compilatore. Trovare errori in fase di compilazione è sempre meglio che aspettare l'esecuzione di quel pezzo di codice.

• constè necessario per il polimorfismo sicuro del tipo. I puntatori (in tutte le loro forme, non solo puntatori non elaborati) sono covarianti solo se lo sono const(Nota: non è lo stesso di "puntatore a const"). Covariance richiede un'interfaccia di sola lettura e la contraddizione richiede un'interfaccia di sola scrittura.

Il secondo di questi ho imparato per primo. Ho iniziato constsolo con l'obiettivo del puntatore e dei parametri di riferimento, fino a quando non ho iniziato a vedere i vantaggi di rilevare errori in precedenza e iniziare a usarlo sulla gente del posto, ecc.

Poi ho appreso che la maggior parte dei messaggi di posta #defineelettronica possono essere sostituiti (in C ++) da costanti globali, con ulteriori vantaggi della sicurezza dei tipi. Quindi l'ho usato anche lì.

Alla fine ho preso una lezione sui sistemi di tipo e sul calcolo lambda e ho appreso che i constnon- consttipi sono fondamentalmente diversi (poiché supportano operazioni diverse) e da allora non ho mai preso in considerazione la possibilità di scrivere codice C ++ senza un uso intenso di const.

Ecco i miei 5 centesimi di ciò che non ho visto menzionare da altri. Quando si passano intorno alle variabili non si desidera passare per valore, a meno che non sia realmente necessario, per evitare ulteriori costruzioni, distruzioni e copie. Quindi, a meno che tu non debba davvero passare per valore, usando riferimenti ovunque, anche se non intendi cambiare il valore passato, si ottiene un significativo aumento delle prestazioni. Per questo motivo, quando si dispone di funzioni che prendono riferimenti a tutti i suoi argomenti, è necessario far sapere al chiamante cosa non modificherà la funzione.

È lo stesso principio, ma volevo solo aggiungere una ragione pratica per usare const.