În acest articol, diferitele funcții ale cuvânt cheie const care se gaseste in C++ sunt discutate. Oricând cuvânt cheie const este atașat cu orice metodă(), variabilă, variabila pointer , iar cu obiectul unei clase previne acel specific obiect/metodă()/variabilă pentru a-și modifica valoarea elementelor de date.

Variabile constante:

Există un anumit set de reguli pentru declararea și inițializarea variabilelor constante:

• The variabilă const nu poate fi lăsat neinițializat în momentul atribuirii.
• Nu i se poate atribui valoare nicăieri în program.
• O valoare explicită trebuia furnizată variabilei constante în momentul declarării variabilei constante.

Mai jos este programul C++ pentru a demonstra conceptul de mai sus:

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

Eroarea întâmpinată pentru declararea greșită : Dacă încercați să inițializați variabila const fără a atribui o valoare explicită, atunci este generată o eroare de compilare (CTE).

tuplu python sortat

Cuvânt cheie constant cu variabile indicator:

Pointerii pot fi declarați cu un cuvânt cheie const. Deci, există trei moduri posibile de a utiliza un cuvânt cheie const cu un indicator, care sunt după cum urmează:

Cand variabila pointer indică o valoare constantă :

Sintaxă:

  const data_type* var_name;>

Mai jos este programul C++ pentru implementarea conceptului de mai sus:

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

Explicaţie: Aici, în cazul de mai sus, i și j sunt două variabile pointer care indică o locație de memorie const int-type și char-type, dar valoarea stocată în aceste locații corespunzătoare poate fi modificată așa cum am făcut mai sus.

In caz contrar , cel va apărea următoarea eroare: Dacă încercăm să modificăm valoarea variabilei const.

ștergeți fișierul în java

Când variabila indicator const indică valoarea :

Sintaxă:

  data_type* const     var_name;>

Mai jos este exemplul pentru a demonstra conceptul de mai sus:

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

Explicaţie: Valorile care sunt stocate în variabilele pointer corespunzătoare i și j sunt modificabile, dar locațiile care sunt semnalate de variabilele pointer const unde sunt stocate valorile corespunzătoare ale lui x și y nu sunt modificabile.

În caz contrar, va apărea următoarea eroare: Variabilele pointer sunt const și indică locațiile în care sunt stocate x și y dacă încercăm să schimbăm locația adresei, atunci ne vom confrunta cu eroarea.

Când pointerul const indică către o variabilă const :

Sintaxă:

  const data_type* const var_name;>

Mai jos este programul C++ pentru a demonstra conceptul de mai sus:

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

Explicaţie: Aici, variabila indicator const indică către variabila const. Deci, nici nu aveți voie să schimbați const variabilă indicator(*P) nici valoarea stocată în locația indicată de aceasta variabilă indicator(*P).

În caz contrar, va apărea următoarea eroare: Aici atât variabila pointer, cât și locațiile indicate de variabila pointer sunt constante, așa că dacă oricare dintre ele este modificată, va apărea următoarea eroare:

converti str în int

Transmiteți valoarea argumentului const unui parametru non-const al unei funcții care cauzează eroare : Transmiterea valorii argumentului const unui parametru non-const al unei funcții nu este validă, vă dă o eroare la timp de compilare.

Mai jos este programul C++ pentru a demonstra conceptul de mai sus:

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

Ieșire: Eroarea la timp de compilare care va apărea ca și cum valoarea const ar fi transmisă oricărui argument non-const al funcției, atunci va apărea următoarea eroare de timp de compilare:

În plus, trecerea indicatorului const nu va duce la nicio eroare, deoarece este creat un alt pointer care indică, de asemenea, către aceeași locație de memorie.

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

Codul este executat fără erori și cei doi pointeri au adrese diferite.

Pe scurt, discuția de mai sus poate fi concluzionată după cum urmează:

1. valoare int = 5; // valoare non-const

2. const int *ptr_1 = &value; // ptr_1 indică o valoare const int, deci acesta este un pointer către o valoare const.

3. int *const ptr_2 = &value; // ptr_2 indică un int, deci acesta este un pointer const către o valoare non-const.

4. const int *const ptr_3 = &value; // ptr_3 indică o valoare const int, deci acesta este un pointer const către o valoare const.

Metode constante:

La fel ca funcțiile membru și argumentele funcției membru, obiectele unei clase pot fi, de asemenea, declarate ca const . Un obiect declarat ca const nu poate fi modificat și, prin urmare, poate invoca numai funcții membre const, deoarece aceste funcții asigură că nu se modifică obiectul.

Sintaxă:

site-uri web de filme similare cu 123movies

const Class_Name Object_name;>

• Când o funcție este declarată ca const, aceasta poate fi apelată pe orice tip de obiect, obiect const, precum și obiecte non-const.
• Ori de câte ori un obiect este declarat ca const, acesta trebuie să fie inițializat în momentul declarării. Cu toate acestea, inițializarea obiectului în timpul declarației este posibilă numai cu ajutorul constructorilor.

Există două moduri de a functie constanta declaraţie:

Declarație de const-funcție ordinară :

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

O funcție const membru a clasei :

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

Mai jos este exemplul unei funcții constante:

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

Următoarea eroare va apărea dacă încercați să apelați funcția non-const dintr-un obiect const

Parametrii funcției constante și tipul de returnare :

Parametrii A function() si tipul returnat al funcției() poate fi declarat constant. Valorile constante nu pot fi modificate, deoarece orice astfel de încercare va genera o eroare de compilare.

Mai jos este programul C++ pentru a implementa abordarea de mai sus:

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

Explicaţie: Următoarea eroare va fi afișată dacă instrucțiunea y = 6 este utilizată în funcția foo():

• // y = 6; o valoare const nu poate fi schimbată sau modificată.

obiect în programarea java

Pentru tipul de returnare const : Tipul de returnare al funcției () este const și astfel ne returnează o valoare întreagă const. Mai jos este programul C++ pentru a implementa abordarea de mai sus:

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

Valoarea returnată va fi o valoare constantă.

De asemenea, nu există nicio problemă substanțială pentru a trece variabila const sau non-const funcției atâta timp cât o transmitem după valoare deoarece este creată o nouă copie. Problema apare atunci când încercăm să transmitem variabila constantă prin referire la funcția al cărei parametru este neconstant. Acest lucru nu ține cont de calificativul const care duce la următoarea eroare:

Pentru tipul de returnare const și parametrul const : Aici, atât tipul returnat, cât și parametrul funcției sunt de tipuri const. Mai jos este programul C++ pentru a implementa abordarea de mai sus:

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

Explicaţie: Aici, atât valorile const, cât și cele non-const pot fi transmise funcției ca parametru const, dar nu avem voie să modificăm apoi valoarea unei variabile transmise deoarece parametrul este const. În caz contrar, ne vom confrunta cu eroarea de mai jos:

// y=9; va da eroarea de compilare deoarece y este const var valoarea sa nu poate fi schimbată.