V tomto článku jsou různé funkce klíčové slovo const který se nachází v C++ jsou diskutovány. Kdykoli klíčové slovo const je připojen k jakékoli metodě(), proměnné, proměnná ukazatele , a s objektem třídy zabraňuje tomu specifické objekt/metoda()/proměnná změnit hodnotu jeho datových položek.

Konstantní proměnné:

Existuje určitá sada pravidel pro deklaraci a inicializaci konstantních proměnných:

• The konst proměnná nelze v době přiřazení nechat neinicializované.
• Nikde v programu jí nelze přiřadit hodnotu.
• V době deklarace konstantní proměnné je třeba zadat explicitní hodnotu konstantní proměnné.

Níže je uveden program C++, který demonstruje výše 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 čelila chybné deklaraci : Pokud se pokusíte inicializovat proměnnou const bez přiřazení explicitní hodnoty, vygeneruje se chyba při kompilaci (CTE).

sql pořadí náhodně

Klíčové slovo Const s proměnnými ukazatele:

Ukazatele lze deklarovat pomocí klíčového slova const. Existují tedy tři možné způsoby použití klíčového slova const s ukazatelem, které jsou následující:

Když pointer variable point to const value :

Syntax:

  const data_type* var_name;>

Níže je uveden program C++ pro implementaci výše uvedeného konceptu:

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

Vysvětlení: Zde ve výše uvedeném případě iaj jsou dvě proměnné ukazatele, které ukazují na paměťové místo const int-type a char-type, ale hodnotu uloženou na těchto odpovídajících místech lze změnit, jak jsme to udělali výše.

v opačném případě , a objeví se následující chyba: Pokud se pokusíme upravit hodnotu proměnné const.

Když proměnná ukazatele const ukazuje na hodnotu :

Syntax:

  data_type* const     var_name;>

Níže je uveden příklad demonstrující výše uvedený koncept:

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

Vysvětlení: Hodnoty, které jsou uloženy v odpovídajících ukazatelových proměnných i a j, jsou modifikovatelné, ale místa, na která ukazují konstantní ukazatelové proměnné, kde jsou uloženy odpovídající hodnoty x a y, nelze modifikovat.

V opačném případě se zobrazí následující chyba: Proměnné ukazatele jsou konstantní a ukazují na místa, kde jsou uloženy x a y, pokud se pokusíme změnit umístění adresy, budeme čelit chybě.

Když ukazatel const ukazuje na proměnnou const :

Syntax:

  const data_type* const var_name;>

Níže je uveden program C++, který demonstruje výše 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>

Vysvětlení: Zde proměnná const pointer ukazuje na proměnnou const. Nemáte tedy dovoleno měnit konst proměnná ukazatele (*P) ani hodnota uložená v místě, na které to ukazuje proměnná ukazatele (*P).

V opačném případě se zobrazí následující chyba: Zde jsou jak proměnná ukazatele, tak místa, na která ukazuje proměnná ukazatele, konstantní, takže pokud se některá z nich změní, objeví se následující chyba:

přepnout metoda java

Předejte hodnotu const-argument non-const parametru funkce způsobující chybu : Předání hodnoty argumentu const do parametru funkce, který není platným parametrem, není platné, dojde k chybě při kompilaci.

Níže je uveden program C++, který demonstruje výše 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ýstup: Chyba při kompilaci, která se objeví, jako kdyby byla hodnota const předána jakémukoli non-const argumentu funkce, pak se objeví následující chyba kompilace:

Navíc předání ukazatele const nebude mít za následek žádnou chybu, protože se vytvoří další ukazatel, který také ukazuje na stejné místo 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 se provede bez chyb a dva ukazatele mají různé adresy.

Stručně řečeno, výše uvedená diskuse může být uzavřena takto:

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

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

3. int *const ptr_2 = &value; // ptr_2 ukazuje na int, takže toto je const ukazatel na non-const hodnotu.

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

Konstantní metody:

Stejně jako členské funkce a argumenty členských funkcí mohou být objekty třídy také deklarovány jako konst . Objekt deklarovaný jako const nelze upravit, a proto může vyvolat pouze členské funkce const, protože tyto funkce zajišťují, že objekt nezmění.

Syntax:

const Class_Name Object_name;>

• Když je funkce deklarována jako const, lze ji volat na jakýkoli typ objektu, objekt const i non-const objekty.
• Kdykoli je objekt deklarován jako const, musí být inicializován v době deklarace. Inicializace objektu při deklaraci je však možná pouze pomocí konstruktorů.

Existují dva způsoby a konstantní funkce prohlášení:

Deklarace obyčejné konst-funkce :

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

Konstantní členská funkce třídy :

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

Níže je uveden příklad konstantní funkce:

tisk výpisu v jazyce 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>

Pokud se pokusíte volat funkci non-const z objektu const, dojde k následující chybě

Parametry konstantní funkce a typ návratu :

Parametry funkce () a návratový typ funkce function() lze deklarovat jako konstantní. Konstantní hodnoty nelze změnit, protože jakýkoli takový pokus vygeneruje chybu při kompilaci.

Níže je uveden program C++ pro implementaci výše uvedeného pří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>

Vysvětlení: Pokud je ve funkci foo() použit příkaz y = 6, zobrazí se následující chyba:

• // y = 6; hodnotu const nelze změnit ani upravit.

Pro const návratový typ : Návratový typ funkce function() je const a vrací nám tedy celočíselnou hodnotu const. Níže je uveden program C++ pro implementaci výše uvedeného přístupu:

// 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ácená hodnota bude konstantní hodnotou.

Také není žádný podstatný problém předat funkci const nebo non-const proměnnou, pokud ji předáváme hodnotou, protože je vytvořena nová kopie. Problém nastává, když se snažíme předat konstantní proměnnou odkazem na funkci, jejíž parametr je nekonstantní. Toto ignoruje kvalifikátor const, což vede k následující chybě:

Pro const návratový typ a parametr const : Zde jsou návratový typ i parametr funkce typu const. Níže je uveden program C++ pro implementaci výše uvedeného pří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>

Vysvětlení: Zde mohou být do funkce jako parametr const předány hodnoty const i non-const, ale pak nesmíme změnit hodnotu předané proměnné, protože parametr je const. V opačném případě budeme čelit níže uvedené chybě:

// y=9; vydá chybu při kompilaci, protože y je const var, jeho hodnotu nelze změnit.