I denne artikel, de forskellige funktioner af const søgeord som findes i C++ diskuteres. Hver gang const søgeord er knyttet til en hvilken som helst metode(), variabel, pointer variabel , og med genstanden for en klasse forhindrer den det specifikke objekt/metode()/variabel for at ændre dens dataelementværdi.

skuespiller zeenat aman

Konstante variabler:

Der er et bestemt sæt regler for deklaration og initialisering af konstante variable:

• Det const variabel kan ikke efterlades uinitialiseret på tidspunktet for opgaven.
• Det kan ikke tildeles værdi nogen steder i programmet.
• Eksplicit værdi skulle angives til konstantvariablen på tidspunktet for erklæringen af ​​konstantvariablen.

Nedenfor er C++-programmet til at demonstrere ovenstående 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>

Fejlen stod for fejlagtig erklæring : Hvis du forsøger at initialisere const-variablen uden at tildele en eksplicit værdi, genereres en kompileringstidsfejl (CTE).

Konst søgeord med pointervariabler:

Pointere kan erklæres med et const nøgleord. Så der er tre mulige måder at bruge et const nøgleord med en pointer på, som er som følger:

Når pointer variabel peger på en const værdi :

Syntaks:

  const data_type* var_name;>

Nedenfor er C++-programmet til at implementere ovenstående koncept:

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

Forklaring: Her i ovenstående tilfælde er i og j to pointervariable, der peger på en hukommelsesplacering const int-type og char-type, men værdien gemt på disse tilsvarende steder kan ændres, som vi har gjort ovenfor.

Ellers , det følgende fejl kommer frem: Hvis vi forsøger at ændre værdien af ​​const-variablen.

Når const pointer-variablen peger på værdien :

Syntaks:

  data_type* const     var_name;>

Nedenfor er eksemplet for at demonstrere ovenstående 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>

Forklaring: Værdierne, der er gemt i den tilsvarende pointervariabel i og j, kan ændres, men de steder, der er påpeget af const-pointer-variabler, hvor de tilsvarende værdier af x og y er gemt, kan ikke ændres.

Ellers vil følgende fejl dukke op: Pointervariablerne er const og peger på de steder, hvor x og y er gemt, hvis vi forsøger at ændre adresseplaceringen, så står vi over for fejlen.

Når const pointer peger på en const variabel :

Syntaks:

  const data_type* const var_name;>

Nedenfor er C++-programmet til at demonstrere ovenstående 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>

Forklaring: Her peger const pointer-variablen på const-variablen. Så du har heller ikke lov til at ændre const pointer variabel(*P) heller ikke værdien, der er gemt på det sted, der peges på pointer variabel(*P).

Ellers vil følgende fejl dukke op: Her er både pointervariablen og placeringerne, der peges af pointervariablen, const, så hvis nogen af ​​dem ændres, vises følgende fejl:

Send const-argument-værdi til en ikke-const-parameter for en funktion, der forårsager fejl : At sende const-argumentværdien til en ikke-const-parameter for en funktion er ikke gyldig, det giver dig en kompileringsfejl.

Nedenfor er C++-programmet til at demonstrere ovenstående 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; }>

Produktion: Kompileringstidsfejlen, der vil fremstå som om const-værdien sendes til et hvilket som helst ikke-const-argument for funktionen, så vises følgende kompileringstidsfejl:

Derudover vil det at sende const pointer ikke resultere i nogen fejl, fordi der oprettes en anden pointer, som også peger på den samme hukommelsesplacering.

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

Koden udføres uden fejl, og de to pointere har forskellige adresser.

I nøddeskal kan ovenstående diskussion konkluderes som følger:

1. int værdi = 5; // ikke-konst værdi

2. const int *ptr_1 = &værdi; // ptr_1 peger på en const int værdi, så dette er en pointer til en const værdi.

3. int *const ptr_2 = &værdi; // ptr_2 peger på en int, så dette er en const pointer til en ikke-konst værdi.

4. const int *const ptr_3 = &værdi; // ptr_3 peger på en const int værdi, så dette er en const pointer til en const værdi.

Konstante metoder:

Ligesom medlemsfunktioner og medlemsfunktionsargumenter kan objekterne i en klasse også erklæres som konst . Et objekt, der er erklæret som const, kan ikke ændres og kan derfor kun påkalde const-medlemsfunktioner, da disse funktioner sikrer, at objektet ikke ændres.

Syntaks:

const Class_Name Object_name;>

• Når en funktion er erklæret som const, kan den kaldes på enhver type objekt, const objekt såvel som ikke-const objekter.
• Når et objekt erklæres som const, skal det initialiseres på tidspunktet for deklarationen. Objektinitialiseringen under erklæringen er dog kun mulig ved hjælp af konstruktører.

Der er to måder at a konstant funktion erklæring:

Almindelig konst-funktionserklæring :

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

En const-medlemsfunktion i klassen :

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

Nedenfor er et eksempel på en konstant funktion:

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

Følgende fejl vil, hvis du prøver at kalde non-const-funktionen fra et const-objekt

Konstante funktionsparametre og returtype :

A function() parametre og return type funktion() kan erklæres som konstant. Konstante værdier kan ikke ændres, da et sådant forsøg vil generere en kompileringsfejl.

Nedenfor er C++-programmet til at implementere ovenstående tilgang:

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

Forklaring: Følgende fejl vil blive vist, hvis sætningen y = 6 bruges i funktionen foo():

• //y = 6; en const-værdi kan ikke ændres eller modificeres.

For const returtype : Returtypen af ​​funktionen() er const, og derfor returnerer den en konstant heltalsværdi til os. Nedenfor er C++-programmet til at implementere ovenstående tilgang:

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

Den returnerede værdi vil være en konstant værdi.

Der er heller ikke noget væsentligt problem at overføre const eller non-const variabel til funktionen, så længe vi overfører den med værdi, fordi en ny kopi oprettes. Problemet opstår, når vi forsøger at overføre konstantvariablen med henvisning til den funktion, hvis parameter er ikke-konstant. Dette ser bort fra const-kvalifikationen, der fører til følgende fejl:

For const return type og const parameter : Her er både returtype og parameter for funktionen af ​​const-typer. Nedenfor er C++-programmet til at implementere ovenstående tilgang:

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

Forklaring: Her kan både const og non-const værdier overføres som const parameter til funktionen, men vi må ikke så ændre værdien af ​​en bestået variabel, fordi parameteren er const. Ellers står vi over for fejlen som nedenfor:

//y=9; det giver kompileringstidsfejlen, da y er const var, dens værdi kan ikke ændres.