V tomto článku sú rôzne funkcie kľúčové slovo const ktorý sa nachádza v C++ sa diskutuje. Kedykoľvek kľúčové slovo const je pripojený s akoukoľvek metódou (), premennou, premenná ukazovateľa a s objektom triedy bráni tomu špecifickému objekt/metóda()/premenná zmeniť hodnotu jeho dátových položiek.

Konštantné premenné:

Existuje určitý súbor pravidiel pre deklaráciu a inicializáciu konštantných premenných:

• The konštantná premenná nemožno ponechať neinicializované v čase priradenia.
• Nikde v programe jej nemožno priradiť hodnotu.
• Explicitná hodnota musela byť poskytnutá konštantnej premennej v čase deklarácie konštantnej premennej.

Nižšie je uvedený program C++, ktorý demonštruje vyššie uvedený koncept:

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

Chyba sa vyskytla pre chybné vyhlásenie : Ak sa pokúsite inicializovať premennú const bez priradenia explicitnej hodnoty, vygeneruje sa chyba pri kompilácii (CTE).

Kľúčové slovo Const s premennými ukazovateľa:

Ukazovatele možno deklarovať pomocou kľúčového slova const. Existujú teda tri možné spôsoby použitia kľúčového slova const s ukazovateľom, ktoré sú nasledovné:

Keď pointer premenná bod na konštantnú hodnotu :

Syntax:

  const data_type* var_name;>

Nižšie je uvedený program C++ na implementáciu vyššie uvedeného konceptu:

pytón ťavej

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

Vysvetlenie: Tu vo vyššie uvedenom prípade iaj sú dve premenné ukazovateľa, ktoré ukazujú na pamäťové miesto const int-type a char-type, ale hodnotu uloženú na týchto zodpovedajúcich miestach je možné zmeniť, ako sme to urobili vyššie.

Inak , a zobrazí sa nasledujúca chyba: Ak sa pokúsime upraviť hodnotu premennej const.

Keď premenná ukazovateľa const ukazuje na hodnotu :

Syntax:

  data_type* const     var_name;>

Nižšie je uvedený príklad na demonštráciu vyššie uvedeného konceptu:

tlačové pole v jazyku Java

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

Vysvetlenie: Hodnoty, ktoré sú uložené v zodpovedajúcej premennej ukazovateľa i a j, sú modifikovateľné, ale miesta, na ktoré poukazujú premenné konštantného ukazovateľa, kde sú uložené zodpovedajúce hodnoty x a y, sa nedajú modifikovať.

V opačnom prípade sa zobrazí nasledujúca chyba: Premenné ukazovateľa sú konštantné a ukazujú na miesta, kde sú uložené x a y, ak sa pokúsime zmeniť umiestnenie adresy, budeme čeliť chybe.

Keď ukazovateľ const ukazuje na premennú const :

Syntax:

  const data_type* const var_name;>

Nižšie je uvedený program C++, ktorý demonštruje vyššie uvedený koncept:

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

Vysvetlenie: Tu premenná ukazovateľa const ukazuje na premennú const. Nie je vám teda dovolené meniť konšt premenná ukazovateľa (*P) ani hodnotu uloženú na mieste, na ktoré to poukazuje premenná ukazovateľa (*P).

V opačnom prípade sa zobrazí nasledujúca chyba: Tu sú premenná ukazovateľa aj miesta, na ktoré ukazuje premenná ukazovateľa, konštantné, takže ak sa niektorá z nich zmení, zobrazí sa nasledujúca chyba:

Odovzdajte hodnotu const-argument do nekonštantného parametra funkcie spôsobujúcej chybu : Odovzdanie hodnoty argumentu const do nekonštantného parametra funkcie nie je platné, spôsobí to chybu pri kompilácii.

Nižšie je uvedený program C++, ktorý demonštruje vyššie uvedený koncept:

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

Výkon: Chyba pri kompilácii, ktorá sa zobrazí, ako keby bola hodnota const odovzdaná akémukoľvek non-const argumentu funkcie, potom sa objaví nasledujúca chyba kompilácie:

Okrem toho odovzdanie ukazovateľa const nebude mať za následok žiadnu chybu, pretože sa vytvorí ďalší ukazovateľ, ktorý tiež ukazuje na to isté miesto v pamäti.

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

Kód sa vykonáva bez akýchkoľvek chýb a dva ukazovatele majú rôzne adresy.

Stručne povedané, vyššie uvedenú diskusiu možno uzavrieť takto:

podreťazec java obsahuje

1. int hodnota = 5; // non-const value

2. const int *ptr_1 = &value; // ptr_1 ukazuje na hodnotu const int, takže toto je ukazovateľ na hodnotu const.

3. int *const ptr_2 = &value; // ptr_2 ukazuje na int, takže toto je konštantný ukazovateľ na non-const hodnotu.

4. const int *const ptr_3 = &value; // ptr_3 ukazuje na hodnotu const int, takže toto je ukazovateľ const na hodnotu const.

Konštantné metódy:

Podobne ako členské funkcie a argumenty členských funkcií, aj objekty triedy môžu byť deklarované ako konšt . Objekt deklarovaný ako const nemožno modifikovať, a preto môže vyvolať iba členské funkcie const, pretože tieto funkcie zaistia, že objekt neupravia.

Syntax:

const Class_Name Object_name;>

• Keď je funkcia deklarovaná ako const, možno ju volať na akýkoľvek typ objektu, na objekt const, ako aj na non-const objekty.
• Vždy, keď je objekt deklarovaný ako const, je potrebné ho inicializovať v čase deklarácie. Inicializácia objektu pri deklarácii je však možná len pomocou konštruktorov.

Existujú dva spôsoby a konštantná funkcia vyhlásenie:

Deklarácia obyčajnej konštantnej funkcie :

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

Konštantná členská funkcia triedy :

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

Nižšie je uvedený príklad konštantnej funkcie:

parciálny odvodený symbol latex

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

Ak sa pokúsite zavolať funkciu non-const z objektu const, objaví sa nasledujúca chyba

Parametre konštantnej funkcie a typ návratu :

Parametre funkcie () a návratový typ funkcie () možno deklarovať ako konštantný. Konštantné hodnoty nemožno zmeniť, pretože každý takýto pokus vygeneruje chybu pri kompilácii.

Nižšie je uvedený program C++ na implementáciu vyššie uvedeného prístupu:

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

Vysvetlenie: Nasledujúca chyba sa zobrazí, ak sa vo funkcii foo() použije príkaz y = 6:

• // y = 6; hodnotu const nemožno zmeniť ani upraviť.

Pre typ návratu const : Návratový typ funkcie function() je const, a preto nám vracia hodnotu const celé číslo. Nižšie je uvedený program C++ na implementáciu vyššie uvedeného prístupu:

java má ďalšie

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

Vrátená hodnota bude konštantná.

Taktiež nie je žiadny podstatný problém odovzdať funkciu const alebo non-const premennú, pokiaľ ju odovzdávame podľa hodnoty, pretože sa vytvorí nová kópia. Problém nastáva, keď sa snažíme odovzdať konštantnú premennú odkazom na funkciu, ktorej parameter je nekonštantný. Toto ignoruje kvalifikátor const, čo vedie k nasledujúcej chybe:

Pre const návratový typ a parameter const : Návratový typ aj parameter funkcie sú tu typu const. Nižšie je uvedený program C++ na implementáciu vyššie uvedeného prístupu:

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

Vysvetlenie: Tu môžu byť hodnoty const aj non-const odovzdané ako parameter const do funkcie, ale potom nemôžeme zmeniť hodnotu odovzdanej premennej, pretože parameter je const. V opačnom prípade budeme čeliť chybe, ako je uvedené nižšie:

// y=9; spôsobí chybu pri kompilácii, pretože y je const var, jeho hodnotu nemožno zmeniť.