In questo articolo, le varie funzioni del parola chiave const che si trova in C++ sono discussi. Ogni volta parola chiave const è collegato con qualsiasi metodo(), variabile, variabile puntatore , e con l'oggetto di una classe impedisce quello specifico oggetto/metodo()/variabile per modificare il valore dei suoi dati.

Variabili costanti:

Esistono alcune regole per la dichiarazione e l'inizializzazione delle variabili costanti:

• IL variabile const non può essere lasciato non inizializzato al momento dell'assegnazione.
• Non è possibile assegnargli un valore in nessun punto del programma.
• È necessario fornire il valore esplicito alla variabile costante al momento della dichiarazione della variabile costante.

Di seguito è riportato il programma C++ per dimostrare il concetto di cui sopra:

// C++ program to demonstrate the // the above concept #include  using namespace std; // Driver Code int main() {  // const int x; CTE error  // x = 9; CTE error  const int y = 10;  cout << y;  return 0; }>

10>

L'errore riscontrato per dichiarazione errata : Se si tenta di inizializzare la variabile const senza assegnare un valore esplicito, viene generato un errore in fase di compilazione (CTE).

Parola chiave Const con variabili puntatore:

I puntatori possono essere dichiarati con una parola chiave const. Quindi, ci sono tre modi possibili per utilizzare una parola chiave const con un puntatore, che sono i seguenti:

Quando il la variabile puntatore punta a un valore const :

Sintassi:

  const data_type* var_name;>

Di seguito è riportato il programma C++ per implementare il concetto di cui sopra:

// C++ program to demonstrate the // above concept #include  using namespace std; // Driver Code int main() {  int x{ 10 };  char y{ 'M' };  const int* i = &x;  const char* j = &y;  // Value of x and y can be altered,  // they are not constant variables  x = 9;  y = 'A';  // Change of constant values because,  // i and j are pointing to const-int  // & const-char type value  // *i = 6;  // *j = 7;  cout << *i << ' ' << *j; }>

9 A>

Spiegazione: Nel caso precedente, i e j sono due variabili puntatore che puntano a una posizione di memoria const int-type e char-type, ma il valore memorizzato in queste posizioni corrispondenti può essere modificato come abbiamo fatto sopra.

Altrimenti , IL apparirà il seguente errore: Se proviamo a modificare il valore della variabile const.

Quando la variabile puntatore const punta al valore :

Sintassi:

  data_type* const     var_name;>

Di seguito è riportato l'esempio per dimostrare il concetto di cui sopra:

// C++ program to demonstrate the // above concept #include  using namespace std; // Driver Code int main() {  // x and z non-const var  int x = 5;  int z = 6;  // y and p non-const var  char y = 'A';  char p = 'C';  // const pointer(i) pointing  // to the var x's location  int* const i = &x;  // const pointer(j) pointing  // to the var y's location  char* const j = &y;  // The values that is stored at the memory location can  // modified even if we modify it through the pointer  // itself No CTE error  *i = 10;  *j = 'D';  // CTE because pointer variable  // is const type so the address  // pointed by the pointer variables  // can't be changed  // i = &z;  // j = &p;  cout << *i << ' and ' << *j << endl;  cout << i << ' and ' << j;  return 0; }>

10 and D 0x7ffe21db72b4 and D>

Spiegazione: I valori memorizzati nella variabile puntatore corrispondente i e j sono modificabili, ma le posizioni indicate dalle variabili const-pointer in cui sono memorizzati i valori corrispondenti di x e y non sono modificabili.

In caso contrario, verrà visualizzato il seguente errore: Le variabili puntatore sono const e puntano alle posizioni in cui sono archiviati x e y. Se proviamo a modificare la posizione dell'indirizzo, ci troveremo di fronte all'errore.

Quando il puntatore const punta a una variabile const :

Sintassi:

  const data_type* const var_name;>

Di seguito è riportato il programma C++ per dimostrare il concetto di cui sopra:

// C++ program to demonstrate // the above concept #include  using namespace std; // Driver code int main() {  int x{ 9 };  const int* const i = &x;  // *i=10;  // The above statement will give CTE  // Once Ptr(*i) value is  // assigned, later it can't  // be modified(Error)  char y{ 'A' };  const char* const j = &y;  // *j='B';  // The above statement will give CTE  // Once Ptr(*j) value is  // assigned, later it can't  // be modified(Error)  cout << *i << ' and ' << *j;  return 0; }>

9 and A>

Spiegazione: Qui, la variabile puntatore const punta alla variabile const. Quindi, non ti è consentito modificare il const variabile puntatore(*P) né il valore memorizzato nella posizione indicata da quello variabile puntatore(*P).

In caso contrario, verrà visualizzato il seguente errore: Qui sia la variabile puntatore che le posizioni puntate dalla variabile puntatore sono const, quindi se una di esse viene modificata, verrà visualizzato il seguente errore:

Passare il valore dell'argomento const a un parametro non const di una funzione causa un errore : Passare il valore dell'argomento const a un parametro non const di una funzione non è valido e genera un errore in fase di compilazione.

Di seguito è riportato il programma C++ per dimostrare il concetto di cui sopra:

// C++ program to demonstrate // the above concept #include  using namespace std; int foo(int* y) { return *y; } // Driver code int main() {  int z = 8;  const int* x = &z;  cout << foo(x);  return 0; }>

Produzione: L'errore in fase di compilazione che apparirà come se il valore const fosse passato a qualsiasi argomento non const della funzione, verrà visualizzato il seguente errore in fase di compilazione:

Inoltre, il passaggio del puntatore const non comporterà alcun errore perché viene creato un altro puntatore che punta anch'esso alla stessa posizione di memoria.

//C++ program to demonstrate the above concept #include  using namespace std; void printfunc(int* ptr) {  cout << 'Value :' << *ptr << endl;  cout << 'Address of ptr :' << &ptr << endl; } //Driver Code int main() {  int x = 10;  int* const i = &x;  printfunc(i);  cout << 'Address of i :' << &i << endl; }>

Value :10 Address of ptr :0x7ffff0189b48 Address of i :0x7ffff0189b70>

Il codice viene eseguito senza errori e i due puntatori hanno indirizzi diversi.

In poche parole, la discussione di cui sopra può essere conclusa come segue:

1. valore intero = 5; // valore non costante

2. const int *ptr_1 = &valore; // ptr_1 punta a un valore const int, quindi questo è un puntatore a un valore const.

3. int *const ptr_2 = &value; // ptr_2 punta a un int, quindi questo è un puntatore const a un valore non const.

4. const int *const ptr_3 = &value; // ptr_3 punta a un valore const int, quindi questo è un puntatore const a un valore const.

Metodi costanti:

Come le funzioni membro e gli argomenti delle funzioni membro, anche gli oggetti di una classe possono essere dichiarati come cost . Un oggetto dichiarato come const non può essere modificato e quindi può richiamare solo funzioni membro const poiché queste funzioni garantiscono di non modificare l'oggetto.

Sintassi:

const Class_Name Object_name;>

• Quando una funzione viene dichiarata come const, può essere chiamata su qualsiasi tipo di oggetto, oggetto const e oggetti non const.
• Ogni volta che un oggetto viene dichiarato come const, deve essere inizializzato al momento della dichiarazione. Tuttavia, l'inizializzazione dell'oggetto durante la dichiarazione è possibile solo con l'aiuto dei costruttori.

Ci sono due modi per a funzione costante dichiarazione:

Dichiarazione ordinaria di funzione const :

  const void foo()    {     //void foo() const Not valid    }          int main()    {     foo();    }>

Una funzione membro const della classe :

  class    {     void foo() const     {     //.....     }    }>

Di seguito è riportato l'esempio di una funzione costante:

// C++ program to demonstrate the // constant function #include  using namespace std; // Class Test class Test {  int value; public:  // Constructor  Test(int v = 0) { value = v; }  // We get compiler error if we  // add a line like 'value = 100;'  // in this function.  int getValue() const { return value; }  // a nonconst function trying to modify value  void setValue(int val) { value = val; } }; // Driver Code int main() {  // Object of the class T  Test t(20);  // non-const object invoking const function, no error  cout << t.getValue() << endl;  // const object  const Test t_const(10);  // const object invoking const function, no error  cout << t_const.getValue() << endl;  // const object invoking non-const function, CTE  // t_const.setValue(15);  // non-const object invoking non-const function, no  // error  t.setValue(12);  cout << t.getValue() << endl;  return 0; }>

20 10 12>

Il seguente errore si verificherà se provi a chiamare la funzione non const da un oggetto const

Parametri di funzione costante e tipo di ritorno :

Una funzione() parametri e il tipo restituito di function() può essere dichiarato come costante. I valori costanti non possono essere modificati poiché qualsiasi tentativo di questo tipo genererà un errore in fase di compilazione.

Di seguito è riportato il programma C++ per implementare l'approccio di cui sopra:

// C++ program to demonstrate the // above approach #include  using namespace std; // Function foo() with variable // const int void foo(const int y) {  // y = 6; const value  // can't be change  cout << y; } // Function foo() with variable int void foo1(int y) {  // Non-const value can be change  y = 5;  cout << '
' << y; } // Driver Code int main() {  int x = 9;  const int z = 10;  foo(z);  foo1(x);  return 0; }>

10 5>

Spiegazione: Se nella funzione foo() viene utilizzata l'istruzione y = 6, verrà visualizzato il seguente errore:

• // y = 6; un valore const non può essere cambiato o modificato.

Per il tipo restituito const : Il tipo restituito della funzione() è const e quindi ci restituisce un valore intero const. Di seguito è riportato il programma C++ per implementare l'approccio di cui sopra:

// C++ program for the above approach #include  using namespace std; const int foo(int y) {  y--;  return y; } int main() {  int x = 9;  const int z = 10;  cout << foo(x) << '
' << foo(z);  return 0; }>

8 9>

Il valore restituito sarà un valore costante.

Inoltre, non vi è alcun problema sostanziale nel passare la variabile const o non const alla funzione fintanto che la passiamo per valore perché viene creata una nuova copia. Il problema sorge quando proviamo a passare la variabile costante facendo riferimento alla funzione il cui parametro non è costante. Ciò ignora il qualificatore const che porta al seguente errore:

entità relazionale

Per il tipo restituito const e il parametro const : Qui, sia il tipo restituito che il parametro della funzione sono di tipo const. Di seguito è riportato il programma C++ per implementare l'approccio di cui sopra:

// C++ program for the above approach #include  using namespace std; const int foo(const int y) {  // y = 9; it'll give CTE error as  // y is const var its value can't  // be change  return y; } // Driver code int main() {  int x = 9;  const int z = 10;  cout << foo(x) << '
' << foo(z);  return 0; }>

9 10>

Spiegazione: Qui, sia i valori const che quelli non const possono essere passati come parametro const alla funzione, ma non ci è consentito modificare il valore di una variabile passata perché il parametro è const. Altrimenti, affronteremo l'errore come di seguito:

// y=9; darà l'errore in fase di compilazione poiché y è const var il suo valore non può essere modificato.