En aquest article, les diferents funcions del paraula clau const que es troba a C++ es discuteixen. Sempre que paraula clau const s'adjunta amb qualsevol mètode (), variable, variable punter , i amb l'objecte d'una classe impedeix que en concret objecte/mètode()/variable per modificar el valor dels elements de dades.

Variables constants:

Hi ha un determinat conjunt de regles per a la declaració i inicialització de les variables constants:

• El variable const no es pot deixar sense inicialitzar en el moment de l'assignació.
• No es pot assignar valor en cap lloc del programa.
• Calia proporcionar un valor explícit a la variable constant en el moment de la declaració de la variable constant.

A continuació es mostra el programa C++ per demostrar el concepte anterior:

// 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'error enfrontat per declaració defectuosa : Si intenteu inicialitzar la variable const sense assignar un valor explícit, es genera un error en temps de compilació (CTE).

Const Paraula clau amb variables de punter:

Els punters es poden declarar amb una paraula clau const. Per tant, hi ha tres maneres possibles d'utilitzar una paraula clau const amb un punter, que són les següents:

Quan el la variable punter apunta a un valor constant :

Sintaxi:

la roda del ratolí no es desplaça correctament

  const data_type* var_name;>

A continuació es mostra el programa C++ per implementar el concepte anterior:

// 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>

Explicació: Aquí, en el cas anterior, i i j són dues variables de punter que apunten a una ubicació de memòria const int-type i char-type, però el valor emmagatzemat en aquestes ubicacions corresponents es pot canviar com hem fet anteriorment.

D'una altra manera , el apareixerà el següent error: Si intentem modificar el valor de la variable const.

Quan la variable punter const apunta al valor :

Sintaxi:

  data_type* const     var_name;>

A continuació es mostra l'exemple per demostrar el concepte anterior:

// 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>

Explicació: Els valors que s'emmagatzemen a la variable de punter corresponent i i j són modificables, però les ubicacions assenyalades per variables de punter constant on s'emmagatzemen els valors corresponents de x i y no són modificables.

En cas contrari, apareixerà el següent error: Les variables del punter són const i apunten a les ubicacions on s'emmagatzemen x i y si intentem canviar la ubicació de l'adreça, ens enfrontarem a l'error.

Quan el punter const apunta a una variable const :

Sintaxi:

jtextfield

  const data_type* const var_name;>

A continuació es mostra el programa C++ per demostrar el concepte anterior:

// 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>

Explicació: Aquí, la variable punter const apunta a la variable const. Per tant, tampoc podeu canviar la const variable punter(*P) ni el valor emmagatzemat a la ubicació assenyalada per això variable punter(*P).

En cas contrari, apareixerà el següent error: Aquí tant la variable punter com les ubicacions apuntades per la variable punter són constants, de manera que si es modifica alguna d'elles, apareixerà el següent error:

Passeu el valor de l'argument const a un paràmetre no const d'una funció causa error : Passar el valor de l'argument const a un paràmetre que no sigui const d'una funció no és vàlid, ja que genera un error en temps de compilació.

A continuació es mostra el programa C++ per demostrar el concepte anterior:

// 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; }>

Sortida: L'error en temps de compilació que apareix com si el valor const es passa a qualsevol argument no constant de la funció, apareixerà el següent error en temps de compilació:

A més, passar el punter const no provocarà cap error perquè es crea un altre punter que també apunta a la mateixa ubicació de memòria.

//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>

El codi s'executa sense cap error i els dos punters tenen adreces diferents.

En poques paraules, la discussió anterior es pot concloure de la següent manera:

1. valor int = 5; // valor no constant

2. const int *ptr_1 = &value; // ptr_1 apunta a un valor const int, de manera que aquest és un punter a un valor const.

3. int *const ptr_2 = &value; // ptr_2 apunta a un int, així que aquest és un punter const a un valor no constant.

4. const int *const ptr_3 = &value; // ptr_3 apunta a un valor const int, de manera que aquest és un punter const a un valor const.

Mètodes constants:

Igual que les funcions membre i els arguments de funció membre, els objectes d'una classe també es poden declarar com const . Un objecte declarat com a const no es pot modificar i, per tant, només pot invocar funcions membre const, ja que aquestes funcions asseguren no modificar l'objecte.

Sintaxi:

const Class_Name Object_name;>

• Quan una funció es declara com a const, es pot cridar a qualsevol tipus d'objecte, objecte const així com objectes no const.
• Sempre que un objecte es declara com a const, s'ha d'inicialitzar en el moment de la declaració. Tanmateix, la inicialització de l'objecte mentre es declara només és possible amb l'ajuda dels constructors.

Hi ha dues maneres d'a funció constant declaració:

compara cadenes java

Declaració de funció ordinària :

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

Una funció membre const de la classe :

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

A continuació es mostra l'exemple d'una funció constant:

// 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>

El següent error es produirà si proveu de cridar la funció no const des d'un objecte const

Paràmetres de funció constant i tipus de retorn :

A function() paràmetres i El tipus de retorn de la funció () es pot declarar com a constant. Els valors constants no es poden canviar, ja que qualsevol intent generarà un error en temps de compilació.

A continuació es mostra el programa C++ per implementar l'enfocament anterior:

// 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>

Explicació: Es mostrarà l'error següent si s'utilitza la sentència y = 6 a la funció foo():

• // y = 6; un valor constant no es pot canviar ni modificar.

Per al tipus de retorn constant : El tipus de retorn de la funció() és const i, per tant, ens retorna un valor enter const. A continuació es mostra el programa C++ per implementar l'enfocament anterior:

// 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>

El valor retornat serà un valor constant.

A més, no hi ha cap problema substancial per passar la variable const o no constant a la funció sempre que la passem per valor perquè es crea una còpia nova. El problema sorgeix quan intentem passar la variable constant per referència a la funció el paràmetre de la qual no és constant. Això no té en compte el qualificador const que condueix a l'error següent:

nucli de java java

Per al tipus de retorn const i el paràmetre const : Aquí, tant el tipus de retorn com el paràmetre de la funció són de tipus const. A continuació es mostra el programa C++ per implementar l'enfocament anterior:

// 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>

Explicació: Aquí, tant els valors const com els no const es poden passar com a paràmetre const a la funció, però no podem canviar el valor d'una variable passada perquè el paràmetre és const. En cas contrari, ens enfrontarem a l'error de la següent manera:

// y=9; donarà l'error en temps de compilació ja que y és const var, el seu valor no es pot canviar.