I denne artikkelen, de ulike funksjonene til const nøkkelord som finnes i C++ er diskutert. Når som helst const nøkkelord er knyttet til en hvilken som helst metode(), variabel, pekervariabel , og med objektet til en klasse forhindrer den den spesifikke objekt/metode()/variabel for å endre dataelementverdien.

skuespiller zeenat aman

Konstante variabler:

Det er et visst sett med regler for deklarasjon og initialisering av konstante variabler:

• De const variabel kan ikke etterlates uinitialisert på tidspunktet for oppdraget.
• Det kan ikke tildeles verdi noe sted i programmet.
• Eksplisitt verdi måtte gis til konstantvariabelen på tidspunktet for erklæringen av konstantvariabelen.

Nedenfor er C++-programmet for å demonstrere konseptet ovenfor:

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

Feilen står overfor feil erklæring : Hvis du prøver å initialisere const-variabelen uten å tilordne en eksplisitt verdi, genereres en kompileringstidsfeil (CTE).

Const nøkkelord med pekervariabler:

Pekere kan deklareres med et const nøkkelord. Så det er tre mulige måter å bruke et const nøkkelord med en peker på, som er som følger:

Når pekervariabel peker på en const-verdi :

Syntaks:

  const data_type* var_name;>

Nedenfor er C++-programmet for å implementere konseptet ovenfor:

// 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 tilfellet ovenfor er i og j to pekervariabler som peker til en minneplassering const int-type og char-type, men verdien som er lagret på disse korresponderende stedene kan endres som vi har gjort ovenfor.

Ellers , de følgende feil vises: Hvis vi prøver å endre verdien av const-variabelen.

Når const-pekervariabelen peker på verdien :

Syntaks:

  data_type* const     var_name;>

Nedenfor er eksemplet for å demonstrere konseptet ovenfor:

// 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: Verdiene som er lagret i den korresponderende pekervariabelen i og j kan endres, men plasseringene som er pekt ut av const-pekervariabler der de tilsvarende verdiene til x og y er lagret, kan ikke endres.

Ellers vil følgende feil vises: Pekervariablene er const og peker til plasseringene der x og y er lagret hvis vi prøver å endre adresseplasseringen, vil vi møte feilen.

Når const-pekeren peker på en const-variabel :

Syntaks:

  const data_type* const var_name;>

Nedenfor er C++-programmet for å demonstrere konseptet ovenfor:

// 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 peker const-pekervariabelen til const-variabelen. Så du har heller ikke lov til å endre const pekervariabel(*P) heller ikke verdien som er lagret på stedet pekt av det pekervariabel(*P).

Ellers vil følgende feil vises: Her er både pekervariabelen og plasseringene som pekes av pekervariabelen const, så hvis noen av dem endres, vil følgende feil vises:

Send const-argument-verdien til en ikke-const-parameter for en funksjon som forårsaker feil : Å sende const-argumentverdien til en ikke-const-parameter for en funksjon er ikke gyldig, det gir deg en kompileringstidsfeil.

Nedenfor er C++-programmet for å demonstrere konseptet ovenfor:

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

Produksjon: Kompileringstidsfeilen som vil vises som om const-verdien sendes til et hvilket som helst ikke-const-argument for funksjonen, så vil følgende kompileringstidsfeil vises:

I tillegg vil bestått const-peker ikke resultere i noen feil fordi det opprettes en annen peker som også peker til samme minneplassering.

//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 kjøres uten feil og de to pekerne har forskjellige adresser.

I nøtteskall kan diskusjonen ovenfor konkluderes som følger:

1. int verdi = 5; // ikke-konst verdi

2. const int *ptr_1 = &verdi; // ptr_1 peker på en const int verdi, så dette er en peker til en const verdi.

3. int *const ptr_2 = &verdi; // ptr_2 peker på en int, så dette er en const-peker til en ikke-konst verdi.

4. const int *const ptr_3 = &verdi; // ptr_3 peker på en const int-verdi, så dette er en const-peker til en const-verdi.

Konstante metoder:

I likhet med medlemsfunksjoner og medlemsfunksjonsargumenter, kan objektene til en klasse også erklæres som konst . Et objekt erklært som const kan ikke endres og kan derfor kun påkalle const-medlemsfunksjoner, da disse funksjonene sikrer at objektet ikke endres.

Syntaks:

const Class_Name Object_name;>

• Når en funksjon er erklært som const, kan den kalles på alle typer objekter, const-objekter så vel som ikke-const-objekter.
• Når et objekt er deklarert som const, må det initialiseres på tidspunktet for deklarasjonen. Imidlertid er gjenstandsinitialisering mens deklarering bare mulig ved hjelp av konstruktører.

Det er to måter å a konstant funksjon erklæring:

Ordinær konst-funksjonserklæring :

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

En konstmedlemsfunksjon i klassen :

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

Nedenfor er et eksempel på en konstant funksjon:

// 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 feil vil, hvis du prøver, kalle opp non-const-funksjonen fra et const-objekt

Konstant funksjonsparametere og returtype :

A function() parametere og returtype funksjon() kan erklæres som konstant. Konstante verdier kan ikke endres ettersom et slikt forsøk vil generere en kompileringstidsfeil.

Nedenfor er C++-programmet for å implementere tilnærmingen ovenfor:

// 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 feil vil vises hvis setningen y = 6 brukes i funksjonen foo():

• //y = 6; en const-verdi kan ikke endres eller modifiseres.

For const returtype : Returtypen til funksjonen() er const, og derfor returnerer den en konstant heltallsverdi til oss. Nedenfor er C++-programmet for å implementere tilnærmingen ovenfor:

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

Verdien som returneres vil være en konstant verdi.

Det er heller ikke noe vesentlig problem å overføre const eller non-const variabel til funksjonen så lenge vi sender den med verdi fordi en ny kopi opprettes. Problemet oppstår når vi prøver å sende konstantvariabelen ved referanse til funksjonen hvis parameter er ikke-konstant. Dette ser bort fra const-kvalifiseringen som fører til følgende feil:

For const returtype og const parameter : Her er både returtype og parameter for funksjonen av const-typer. Nedenfor er C++-programmet for å implementere tilnærmingen ovenfor:

// 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 ikke-const-verdier sendes som const-parameter til funksjonen, men vi har ikke lov til å endre verdien på en bestått variabel fordi parameteren er const. Ellers vil vi møte feilen som nedenfor:

// y=9; det vil gi kompileringstidsfeilen da y er const var verdien kan ikke endres.