Šiame straipsnyje pateikiamos įvairios funkcijos const raktažodis kuris randamas C++ yra aptariami. Kai kada const raktažodis pridedamas naudojant bet kurį metodą (), kintamąjį, rodyklės kintamasis , o su klasės objektu jis užkerta kelią tam konkrečiam objektas/metodas()/kintamasis pakeisti jo duomenų elementų vertę.

Pastovūs kintamieji:

Yra tam tikras pastovių kintamųjų deklaravimo ir inicijavimo taisyklių rinkinys:

• The const kintamasis negali būti paliktas inicijuotas pavedimo metu.
• Jai negalima priskirti reikšmės bet kurioje programos vietoje.
• Pastoviam kintamajam deklaruojant pastovųjį kintamąjį reikėjo pateikti aiškią vertę.

Žemiau yra C ++ programa, skirta parodyti aukščiau pateiktą koncepciją:

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

Klaida, su kuria susidurta dėl klaidingos deklaracijos : Jei bandote inicijuoti kintamąjį const nepriskirdami aiškios reikšmės, sugeneruojama kompiliavimo laiko klaida (CTE).

Const raktinis žodis su rodyklės kintamaisiais:

Rodyklės gali būti deklaruojamos naudojant const raktinį žodį. Taigi, yra trys galimi būdai, kaip naudoti raktinį žodį const su žymekliu, kurie yra tokie:

Kai rodyklės kintamasis nurodo const reikšmę :

Sintaksė:

  const data_type* var_name;>

Žemiau yra C++ programa, skirta įgyvendinti aukščiau pateiktą koncepciją:

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

Paaiškinimas: Šiuo atveju i ir j yra du žymeklio kintamieji, nukreipiantys į atminties vietą const int-type ir char-type, tačiau šiose atitinkamose vietose saugomą reikšmę galima pakeisti, kaip tai padarėme aukščiau.

Priešingu atveju , į pasirodys ši klaida: Jei bandysime modifikuoti kintamojo const reikšmę.

Kai const rodyklės kintamasis nurodo reikšmę :

Sintaksė:

modifikavimo klavišai

  data_type* const     var_name;>

Žemiau pateikiamas pavyzdys, rodantis aukščiau pateiktą koncepciją:

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

Paaiškinimas: Reikšmės, saugomos atitinkamame žymeklio kintamajame i ir j, yra keičiamos, tačiau vietos, kurias nurodo const-pointer kintamieji, kur saugomos atitinkamos x ir y reikšmės, nėra keičiamos.

Priešingu atveju pasirodys ši klaida: Rodyklės kintamieji yra const ir nurodo vietas, kuriose saugomi x ir y, jei bandysime pakeisti adreso vietą, susidursime su klaida.

Kai const rodyklė nukreipia į const kintamąjį :

Sintaksė:

  const data_type* const var_name;>

Žemiau yra C ++ programa, skirta parodyti aukščiau pateiktą koncepciją:

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

Paaiškinimas: Čia const rodyklės kintamasis nurodo const kintamąjį. Taigi, jums taip pat neleidžiama keisti konst rodyklės kintamasis (*P) nei to nurodytoje vietoje saugomos vertės rodyklės kintamasis (*P).

Priešingu atveju pasirodys ši klaida: Čia ir žymeklio kintamasis, ir žymeklio kintamojo nurodytos vietos yra pastovios, todėl jei kuris nors iš jų bus pakeistas, pasirodys ši klaida:

Perduoti const-argumento reikšmę ne const funkcijos parametrui sukelia klaidą : Argumento const vertės perdavimas ne const funkcijos parametrui yra netinkamas, todėl atsiranda kompiliavimo laiko klaida.

Žemiau yra C ++ programa, skirta parodyti aukščiau pateiktą koncepciją:

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

Išvestis: Kompiliavimo laiko klaida, kuri pasirodys taip, tarsi const reikšmė būtų perduota bet kuriam funkcijos ne const argumentui, tada pasirodys ši kompiliavimo laiko klaida:

Be to, perdavus const žymeklį nebus jokios klaidos, nes sukuriama kita rodyklė, kuri taip pat nurodo į tą pačią atminties vietą.

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

Kodas vykdomas be klaidų, o dvi rodyklės turi skirtingus adresus.

Trumpai tariant, aukščiau pateiktą diskusiją galima baigti taip:

1. int reikšmė = 5; // nekonst. reikšmė

išskyrus

2. const int *ptr_1 = &value; // ptr_1 nurodo const int reikšmę, taigi tai yra žymeklis į const reikšmę.

3. int *const ptr_2 = &value; // ptr_2 nurodo int, taigi tai yra const rodyklė į ne const reikšmę.

4. const int *const ptr_3 = &value; // ptr_3 nurodo const int reikšmę, taigi tai yra const rodyklė į const reikšmę.

Nuolatiniai metodai:

Kaip ir narių funkcijos bei narių funkcijų argumentai, klasės objektai taip pat gali būti deklaruojami kaip konst . Objektas, paskelbtas kaip const, negali būti modifikuojamas, todėl gali iškviesti tik const narių funkcijas, nes šios funkcijos užtikrina, kad objektas nebus modifikuotas.

Sintaksė:

const Class_Name Object_name;>

• Kai funkcija deklaruojama kaip const, ją galima iškviesti bet kokio tipo objektuose, const objektuose ir ne const objektuose.
• Kai objektas deklaruojamas kaip const, jį reikia inicijuoti deklaravimo metu. Tačiau objekto inicijavimas deklaruojant galimas tik konstruktorių pagalba.

Yra du būdai a pastovi funkcija deklaracija:

Įprastos konst-funkcijos deklaracija :

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

Klasės const nario funkcija :

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

Žemiau pateikiamas pastovios funkcijos pavyzdys:

ilgas į eilutę java

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

Jei bandysite iškviesti funkciją ne const iš const objekto, atsiras ši klaida

Pastovios funkcijos parametrai ir grąžinimo tipas :

Funkcijos() parametrai ir Funkcijos () grąžinimo tipas gali būti deklaruojamas kaip pastovus. Pastovios reikšmės negali būti keičiamos, nes bet koks toks bandymas sugeneruos kompiliavimo laiko klaidą.

Žemiau yra C++ programa, skirta įgyvendinti aukščiau nurodytą metodą:

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

Paaiškinimas: Jei funkcijoje foo () naudojamas teiginys y = 6, bus rodoma ši klaida:

• // y = 6; const vertės negalima keisti ar modifikuoti.

Dėl pastovaus grąžinimo tipo : Funkcijos() grąžinimo tipas yra const, todėl ji mums grąžina sveikojo skaičiaus reikšmę const. Žemiau yra C++ programa, skirta įgyvendinti aukščiau nurodytą metodą:

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

Grąžinama vertė bus pastovi.

Be to, nėra didelių problemų perduoti funkcijai kintamąjį const arba ne const, jei perduodame jį pagal vertę, nes sukuriama nauja kopija. Problema iškyla, kai bandome perduoti pastovų kintamąjį pagal funkciją, kurios parametras yra nepastovus. Tai nepaiso const kvalifikatoriaus, dėl kurio atsiranda ši klaida:

Const grąžinimo tipui ir const parametrui : Čia tiek grąžinimo tipas, tiek funkcijos parametras yra const tipo. Žemiau yra C++ programa, skirta įgyvendinti aukščiau nurodytą metodą:

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

Paaiškinimas: Čia ir const, ir ne const reikšmės gali būti perduodamos kaip const parametras funkcijai, tačiau tada mes negalime keisti perduodamo kintamojo reikšmės, nes parametras yra const. Priešingu atveju susidursime su tokia klaida:

// y=9; ji pateiks kompiliavimo laiko klaidą, nes y yra const var, jo vertės pakeisti negalima.