V tem članku so različne funkcije ključna beseda const ki se nahaja v C++ se razpravlja. Kadarkoli ključna beseda const je pritrjen s katero koli metodo(), spremenljivko, spremenljivka kazalca , in s predmetom razreda preprečuje to specifično objekt/metoda()/spremenljivka da spremenite vrednost svojih podatkovnih elementov.

Konstantne spremenljivke:

Obstaja določen niz pravil za deklaracijo in inicializacijo konstantnih spremenljivk:

• The spremenljivka const v času dodelitve ni mogoče pustiti neinicializiranega.
• Nikjer v programu mu ni mogoče dodeliti vrednosti.
• Konstantni spremenljivki je bilo treba zagotoviti eksplicitno vrednost v času deklaracije konstantne spremenljivke.

Spodaj je program C++ za predstavitev zgornjega koncepta:

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

Napaka zaradi napačne deklaracije : Če poskušate inicializirati spremenljivko const brez dodelitve eksplicitne vrednosti, se ustvari napaka med prevajanjem (CTE).

Konstantna ključna beseda s spremenljivkami kazalca:

Kazalce je mogoče deklarirati s ključno besedo const. Torej obstajajo trije možni načini uporabe ključne besede const s kazalcem, ki so naslednji:

Ko spremenljivka kazalca kaže na konstantno vrednost :

Sintaksa:

  const data_type* var_name;>

Spodaj je program C++ za implementacijo zgornjega koncepta:

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

Pojasnilo: V zgornjem primeru sta i in j dve spremenljivki kazalca, ki kažeta na pomnilniško lokacijo const int-type in char-type, vendar je mogoče vrednost, shranjeno na teh ustreznih lokacijah, spremeniti, kot smo storili zgoraj.

V nasprotnem primeru , the pojavila se bo naslednja napaka: Če poskušamo spremeniti vrednost spremenljivke const.

java boolean

Ko spremenljivka kazalca const kaže na vrednost :

Sintaksa:

  data_type* const     var_name;>

Spodaj je primer za prikaz zgornjega koncepta:

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

Pojasnilo: Vrednosti, ki so shranjene v ustrezni kazalni spremenljivki i in j, je mogoče spreminjati, vendar lokacij, ki jih kažejo spremenljivke konstantnega kazalca, kjer so shranjene ustrezne vrednosti x in y, ni mogoče spreminjati.

V nasprotnem primeru se prikaže naslednja napaka: Spremenljivke kazalca so const in kažejo na lokacije, kjer sta shranjena x in y, če poskušamo spremeniti lokacijo naslova, se bomo soočili z napako.

Ko kazalec const kaže na spremenljivko const :

Sintaksa:

  const data_type* const var_name;>

Spodaj je program C++ za predstavitev zgornjega koncepta:

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

Pojasnilo: Tukaj spremenljivka kazalca const kaže na spremenljivko const. Torej vam ni dovoljeno spreminjati konst spremenljivka kazalca (*P) niti vrednost, shranjena na lokaciji, ki jo to kaže spremenljivka kazalca (*P).

V nasprotnem primeru se prikaže naslednja napaka: Tu sta spremenljivka kazalca in lokacije, na katere kaže spremenljivka kazalca, konstantne, tako da se bo, če je katera od njih spremenjena, pojavila naslednja napaka:

seznami iz lateksa

Posredovanje vrednosti argumenta const nekonstantnemu parametru funkcije povzroči napako : Posredovanje vrednosti argumenta const parametru funkcije, ki ni const, ni veljavno, povzroči napako med prevajanjem.

Spodaj je program C++ za predstavitev zgornjega koncepta:

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

Izhod: Napaka v času prevajanja, ki se prikaže, kot da je vrednost const posredovana kateremu koli nekonstantnemu argumentu funkcije, potem se pojavi naslednja napaka v času prevajanja:

Poleg tega podajanje kazalca const ne bo povzročilo nobene napake, ker je ustvarjen drug kazalec, ki prav tako kaže na isto pomnilniško lokacijo.

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

Koda se izvede brez napak in oba kazalca imata različna naslova.

Na kratko lahko zgornjo razpravo zaključimo takole:

metoda podniza java

1. int vrednost = 5; // nekonstantna vrednost

2. const int *ptr_1 = &value; // ptr_1 kaže na vrednost const int, torej je to kazalec na vrednost const.

3. int *const ptr_2 = &value; // ptr_2 kaže na int, torej je to konstanten kazalec na nekonstantno vrednost.

4. const int *const ptr_3 = &value; // ptr_3 kaže na vrednost const int, torej je to kazalec const na vrednost const.

Konstantne metode:

Tako kot funkcije članov in argumente funkcij članov je tudi objekte razreda mogoče deklarirati kot konst . Objekta, deklariranega kot const, ni mogoče spreminjati in zato lahko prikliče samo funkcije člana const, saj te funkcije zagotavljajo, da se objekt ne spremeni.

Sintaksa:

const Class_Name Object_name;>

• Ko je funkcija deklarirana kot const, jo je mogoče poklicati na katero koli vrsto objekta, const objekt kot tudi nekonstanten objekt.
• Kadarkoli je objekt deklariran kot const, ga je treba inicializirati v času deklaracije. Vendar pa je inicializacija objekta med deklariranjem možna samo s pomočjo konstruktorjev.

Obstajata dva načina a stalna funkcija izjava:

Deklaracija navadne funkcije const :

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

Konstantna članska funkcija razreda :

preveri različico java na linuxu

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

Spodaj je primer konstantne funkcije:

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

Naslednja napaka se pojavi, če poskusite poklicati nekonstantno funkcijo iz objekta const

Parametri konstantne funkcije in vrnjena vrsta :

Parametri funkcije() in povratni tip funkcije() je mogoče deklarirati kot konstanto. Konstantnih vrednosti ni mogoče spremeniti, ker bo vsak tak poskus povzročil napako med prevajanjem.

Spodaj je program C++ za implementacijo zgornjega pristopa:

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

Pojasnilo: Če je v funkciji foo() uporabljen stavek y = 6, bo prikazana naslednja napaka:

• // y = 6; vrednosti const ni mogoče spremeniti ali spremeniti.

Za povratni tip const : Tip vrnitve funkcije() je const, zato nam vrne konstantno celoštevilsko vrednost. Spodaj je program C++ za implementacijo zgornjega pristopa:

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

Vrnjena vrednost bo konstantna vrednost.

Prav tako ni nobene bistvene težave pri posredovanju spremenljivke const ali non-const funkciji, dokler jo posredujemo po vrednosti, ker je ustvarjena nova kopija. Težava se pojavi, ko poskušamo posredovati konstantno spremenljivko s sklicevanjem na funkcijo, katere parameter ni konstanten. To ne upošteva kvalifikatorja const, kar vodi do naslednje napake:

Za povratni tip const in parameter const : Tukaj sta vrnjeni tip in parameter funkcije konstantnega tipa. Spodaj je program C++ za implementacijo zgornjega pristopa:

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

Pojasnilo: Tukaj lahko kot parameter const v funkcijo posredujemo tako konstantne kot nekonstantne vrednosti, vendar nam ni dovoljeno spremeniti vrednosti posredovane spremenljivke, ker je parameter const. V nasprotnem primeru se bomo soočili s spodnjo napako:

// y=9; dal bo napako med prevajanjem, ker je y const var, njegove vrednosti ni mogoče spremeniti.