Vendimi sulla costante correttezza

Quindi, perché è sempre consigliabile utilizzare const il più spesso possibile? Mi sembra che usare const possa essere più una seccatura che un aiuto in C ++. Ma poi di nuovo, sto arrivando a questo dal punto di vista di Python: se non vuoi che qualcosa cambi, non cambiarlo. Detto questo, ecco alcune domande:

1. Sembra che ogni volta che segnare qualcosa come const, ricevo un errore e devo cambiare qualche altra funzione da qualche parte per essere const. Quindi questo mi fa cambiare un'altra funzione da qualche altra parte. È qualcosa che diventa più semplice con l'esperienza?

2. I vantaggi dell'utilizzo di const sono davvero sufficienti a compensare il problema? Se non hai intenzione di cambiare un oggetto, perché non semplicemente non scrivere codice che non lo modifica?

Dovrei notare che a questo punto, mi concentro maggiormente sui vantaggi dell'utilizzo di const per scopi di correttezza e manutenibilità, anche se è anche bello avere un'idea delle implicazioni sulle prestazioni.

Questo è l'articolo definitivo su "const correttezza": https://isocpp.org/wiki/faq/const-correctness .

In breve, usare const è una buona pratica perché ...

1. Ti protegge dalla modifica accidentale di variabili che non sono destinate a essere modificate,
2. Ti protegge dall'assegnazione di variabili accidentali e

3. Il compilatore può ottimizzarlo. Ad esempio, sei protetto da

   if( x = y ) // whoops, meant if( x == y )

Allo stesso tempo, il compilatore può generare codice più efficiente perché sa esattamente quale sarà lo stato della variabile / funzione in ogni momento. Se stai scrivendo codice C ++ stretto, questo è buono.

Hai ragione nel dire che può essere difficile usare coerenza costante, ma il codice finale è più conciso e sicuro da programmare. Quando si fa molto sviluppo C ++, i vantaggi di questo si manifestano rapidamente.

Ecco un pezzo di codice con un errore comune da cui la correttezza costante può proteggerti da:

void foo(const int DEFCON)
{
   if (DEFCON = 1)     //< FLAGGED AS COMPILER ERROR! WORLD SAVED!
   {
       fire_missiles();
   }
}

Sembra che ogni volta che segnare qualcosa come const, ricevo un errore e devo cambiare qualche altra funzione da qualche parte per essere const. Quindi questo mi fa cambiare un'altra funzione da qualche altra parte. È qualcosa che diventa più semplice con l'esperienza?

Per esperienza, questo è un mito totale. Succede quando non const-correct si trova con codice const-correct, certo. Se si progetta const-correct dall'inizio, questo non dovrebbe MAI costituire un problema. Se fai qualcosa di const, e poi qualcos'altro non si compila, il compilatore ti sta dicendo qualcosa di estremamente importante e dovresti prenderti il ​​tempo per risolverlo correttamente .

Non fa per te quando scrivi il codice inizialmente. È per qualcun altro (o tu qualche mese dopo) che sta guardando la dichiarazione del metodo all'interno della classe o dell'interfaccia per vedere cosa fa. Non modificare un oggetto è un'informazione significativa da cui trarre profitto.

Se usi const rigorosamente, rimarrai sorpreso da quante poche variabili reali ci siano nella maggior parte delle funzioni. Spesso non più di un contatore di loop. Se il tuo codice sta raggiungendo quel punto, senti una calda sensazione dentro ... convalida per compilazione ... il regno della programmazione funzionale è vicino ... puoi quasi toccarlo ora ...

const è una promessa che stai facendo come sviluppatore e che sta cercando l'aiuto del compilatore per far rispettare.

Le mie ragioni per essere const-correct:

• Comunica ai clienti della tua funzione che non modificherai la variabile o l'oggetto
• Accettare argomenti per riferimento costante ti dà l'efficienza del passaggio per riferimento con la sicurezza del passaggio per valore.
• Scrivere le interfacce come const corrette consentirà ai client di usarle. Se si scrive la propria interfaccia per accettare riferimenti non costanti, i client che utilizzano const dovranno eliminare la costanza per poter lavorare con l'utente. Ciò è particolarmente fastidioso se la tua interfaccia accetta caratteri non costanti * e i tuoi clienti usano std :: stringhe, poiché puoi ottenere solo un carattere const * da loro.
• Usando const arruolerai il compilatore per mantenerti onesto in modo da non cambiare erroneamente qualcosa che non dovrebbe cambiare.

La mia filosofia è che se hai intenzione di usare un linguaggio schizzinoso con controlli del tempo di compilazione che sfruttarlo al meglio, puoi farlo. constè un modo forzato di compilazione per comunicare ciò che intendi ... è meglio di quanto non lo siano mai i commenti o doxygen. Stai pagando il prezzo, perché non derivarne il valore?

Programmare C ++ senza const è come guidare senza la cintura di sicurezza.

Indossare la cintura di sicurezza ogni volta che sali in macchina è una seccatura e 364 giorni su 365 arriverai in sicurezza.

L'unica differenza è che quando hai problemi con la tua auto la sentirai immediatamente, mentre con la programmazione senza const potresti dover cercare per due settimane ciò che ha causato quell'incidente solo per scoprire che hai inavvertitamente incasinato un argomento di funzione che hai passato per riferimento non const per efficienza.

Per la programmazione integrata, l'utilizzo con constprudenza durante la dichiarazione di strutture di dati globali può far risparmiare molta RAM, facendo sì che i dati costanti si trovino nella ROM o nel flash senza copiarli nella RAM all'avvio.

Nella programmazione quotidiana, l'uso constattento ti aiuta a evitare di scrivere programmi che si arrestano in modo anomalo o si comportano in modo imprevedibile perché tentano di modificare valori letterali di stringa e altri dati globali costanti.

Quando si lavora con altri programmatori su progetti di grandi dimensioni, l'utilizzo constcorretto aiuta a prevenire la limitazione degli altri programmatori.

constti aiuta a isolare il codice che "cambia le cose" alle tue spalle. Quindi, in una classe, contrassegneresti tutti i metodi che non cambiano lo stato dell'oggetto come const. Ciò significa che le constistanze di quella classe non saranno più in grado di chiamare nessun non- constmetodo. In questo modo, ti viene impedito di chiamare accidentalmente funzionalità che possono modificare il tuo oggetto.

Inoltre, constfa parte del meccanismo di sovraccarico, quindi puoi avere due metodi con firme identiche, ma uno con conste uno senza. L'uno con constviene chiamato per i constriferimenti e l'altro per i non constriferimenti.

Esempio:

#include <iostream>

class HelloWorld {
    bool hw_called;

public:
    HelloWorld() : hw_called(false) {}

    void hw() const {
        std::cout << "Hello, world! (const)\n";
        // hw_called = true;  <-- not allowed
    }

    void hw() {
        std::cout << "Hello, world! (non-const)\n";
        hw_called = true;
    }
};

int
main()
{
    HelloWorld hw;
    HelloWorld* phw1(&hw);
    HelloWorld const* phw2(&hw);

    hw.hw();    // calls non-const version
    phw1->hw(); // calls non-const version
    phw2->hw(); // calls const version
    return 0;
}

la correttezza const è una di quelle cose che hanno davvero bisogno di essere in atto fin dall'inizio. Come hai scoperto, è un grande dolore aggiungerlo in seguito, soprattutto quando c'è molta dipendenza tra le nuove funzioni che stai aggiungendo e le vecchie funzioni non corrette che già esistono.

In un sacco di codice che scrivo, ne è valsa davvero la pena perché tendiamo a usare molto la composizione:

class A { ... }
class B { A m_a; const A& getA() const { return m_a; } };

Se non avessimo la correttezza const, allora dovresti ricorrere al ritorno di oggetti complessi in base al valore per assicurarti che nessuno stesse manipolando lo stato interno della classe B alle tue spalle.

In breve, la correttezza const è un meccanismo di programmazione difensiva per salvarti dal dolore lungo la strada.

Supponi di avere una variabile in Python. Sai che non dovresti modificarlo. E se lo fai accidentalmente?

Il C ++ ti offre un modo per proteggerti dal fare accidentalmente qualcosa che prima non avresti dovuto fare. Tecnicamente puoi aggirarlo comunque, ma devi fare un lavoro extra per spararti.

C'è un bell'articolo qui su const in c ++. È un'opinione piuttosto semplice ma spero che possa aiutare alcuni.

Quando usi la parola chiave "const", stai specificando un'altra interfaccia per le tue classi. C'è un'interfaccia che include tutti i metodi e un'interfaccia che include solo i metodi const. Ovviamente questo ti consente di limitare l'accesso ad alcune cose che non desideri vengano modificate.

Sì, diventa più facile con il tempo.

Mi piace la correttezza const ... in teoria. Ogni volta che ho provato ad applicarlo rigorosamente in pratica, alla fine si è rotto e const_cast inizia a insinuarsi nel rendere brutto il codice.

Forse sono solo i motivi di design che uso, ma const finisce sempre per essere un pennello troppo ampio.

Ad esempio, immagina un semplice motore di database ... ha oggetti schema, tabelle, campi ecc. Un utente può avere un puntatore "const Table" che significa che non gli è permesso di modificare lo schema della tabella stessa ... ma per quanto riguarda la manipolazione i dati associati alla tabella? Se il metodo Insert () è contrassegnato da const, allora internamente deve gettare via la costanza per manipolare effettivamente il database. Se non è contrassegnato const, non protegge dal richiamo del metodo AddField.

Forse la risposta è quella di dividere la classe in base ai requisiti di costanza, ma ciò tende a complicare il design più di quanto vorrei per il vantaggio che ne deriva.

Puoi dare suggerimenti al compilatore anche con const .... come da codice seguente

#include <string>

void f(const std::string& s)
{

}
void x( std::string& x)
{
}
void main()
{
    f("blah");
    x("blah");   // won't compile...
}