I den här artikeln, de olika funktionerna const nyckelord som finns i C++ är diskuterade. Närhelst const nyckelord är kopplad med valfri metod(), variabel, pekare variabel , och med objektet för en klass förhindrar den det specifika object/method()/variabel för att ändra dess datapostvärde.

Konstanta variabler:

Det finns en viss uppsättning regler för deklaration och initiering av konstanta variabler:

• De const variabel kan inte lämnas oinitierad vid tidpunkten för uppdraget.
• Det kan inte tilldelas värde någonstans i programmet.
• Explicit värde behövde ges till konstantvariabeln vid tidpunkten för deklarationen av konstantvariabeln.

Nedan är C++-programmet för att demonstrera ovanstå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>

Felet stod inför felaktig deklaration : Om du försöker initiera const-variabeln utan att tilldela ett explicit värde genereras ett kompileringstidsfel (CTE).

Konst nyckelord med pekarvariabler:

Pekare kan deklareras med ett const nyckelord. Så det finns tre möjliga sätt att använda ett const nyckelord med en pekare, som är följande:

När pekarvariabel pekar på ett const-värde :

Syntax:

  const data_type* var_name;>

Nedan är C++-programmet för att implementera ovanstå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>

Förklaring: Här i ovanstående fall är i och j två pekvariabler som pekar på en minnesplats const int-type och char-type, men värdet som lagras på dessa motsvarande platser kan ändras som vi har gjort ovan.

Annat , de följande fel kommer att visas: Om vi ​​försöker ändra värdet på variabeln const.

När const-pekarens variabel pekar på värdet :

Syntax:

huvudmetod java

  data_type* const     var_name;>

Nedan är exemplet för att demonstrera ovanstå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>

Förklaring: Värdena som är lagrade i motsvarande pekarvariabel i och j är modifierbara, men de platser som pekas ut av const-pekarvariabler där motsvarande värden för x och y lagras är inte modifierbara.

Annars kommer följande fel att visas: Pekarvariablerna är const och pekar på platserna där x och y är lagrade om vi försöker ändra adressplatsen så kommer vi att möta felet.

När const-pekaren pekar på en const-variabel :

Syntax:

  const data_type* const var_name;>

Nedan är C++-programmet för att demonstrera ovanstå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>

Förklaring: Här pekar const-pekarvariabeln på const-variabeln. Så du får inte heller ändra konsten pekarvariabel(*P) inte heller värdet lagrat på den plats som pekas av det pekarvariabel(*P).

Annars kommer följande fel att visas: Här är både pekarvariabeln och platserna som pekas av pekarvariabeln const, så om någon av dem ändras kommer följande fel att visas:

Skicka const-argument-värdet till en icke-const-parameter för en funktion som orsakar fel : Att skicka const-argumentvärdet till en icke-const-parameter för en funktion är inte giltigt, det ger dig ett kompileringsfel.

Nedan är C++-programmet för att demonstrera ovanstå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: Kompileringstidsfelet som kommer att visas som om const-värdet skickas till något icke-const-argument för funktionen, då kommer följande kompileringstidsfel att visas:

Dessutom kommer att skicka const-pekaren inte att resultera i något fel eftersom en annan pekare skapas som också pekar på samma minnesplats.

//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 exekveras utan några fel och de två pekarna har olika adresser.

I ett nötskal kan diskussionen ovan avslutas på följande sätt:

1. int värde = 5; // icke-konst värde

hur man läser från en csv-fil i java

2. const int *ptr_1 = &värde; // ptr_1 pekar på ett const int-värde, så detta är en pekare till ett const-värde.

3. int *const ptr_2 = &värde; // ptr_2 pekar på en int, så detta är en const-pekare till ett icke-const-värde.

4. const int *const ptr_3 = &värde; // ptr_3 pekar på ett const int-värde, så detta är en const-pekare till ett const-värde.

Konstanta metoder:

Liksom medlemsfunktioner och medlemsfunktionsargument kan objekten i en klass också deklareras som konst . Ett objekt som deklarerats som const kan inte modifieras och kan därför endast anropa const-medlemsfunktioner eftersom dessa funktioner säkerställer att objektet inte ändras.

Syntax:

const Class_Name Object_name;>

• När en funktion deklareras som const, kan den anropas på vilken typ av objekt som helst, const-objekt såväl som icke-const-objekt.
• Närhelst ett objekt deklareras som const, måste det initieras vid tidpunkten för deklarationen. Emellertid är objektinitieringen under deklarering endast möjlig med hjälp av konstruktörer.

Det finns två sätt att a konstant funktion deklaration:

Vanlig konstfunktionsdeklaration :

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

En konstmedlemsfunktion i klassen :

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

Nedan är ett exempel på en konstant funktion:

hur stor är min skärm

// 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öljande fel kommer om du försöker anropa non-const-funktionen från ett const-objekt

Konstant funktionsparametrar och returtyp :

A function() parametrar och returtyp av funktion() kan deklareras som konstant. Konstanta värden kan inte ändras eftersom ett sådant försök kommer att generera ett kompileringsfel.

Nedan är C++-programmet för att implementera ovanstående tillvägagångssätt:

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

Förklaring: Följande fel kommer att visas om satsen y = 6 används i funktionen foo():

• //y = 6; ett const-värde kan inte ändras eller modifieras.

För const returtyp : Returtypen för funktionen() är const och därför returnerar den ett const-heltalsvärde till oss. Nedan är C++-programmet för att implementera ovanstående tillvägagångssätt:

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

Det returnerade värdet kommer att vara ett konstant värde.

Dessutom finns det inga väsentliga problem att skicka const eller non-const variabel till funktionen så länge vi skickar den med värde eftersom en ny kopia skapas. Problemet uppstår när vi försöker skicka konstantvariabeln med hänvisning till funktionen vars parameter är icke-konstant. Detta bortser från const-kvalificeringen som leder till följande fel:

För const returtyp och const parameter : Här är både returtyp och parameter för funktionen av const-typer. Nedan är C++-programmet för att implementera ovanstående tillvägagångssätt:

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

Förklaring: Här kan både const och non-const värden skickas som const parameter till funktionen, men vi får inte ändra värdet på en överförd variabel eftersom parametern är const. Annars kommer vi att möta felet enligt nedan:

//y=9; det ger kompileringstidsfelet eftersom y är const var dess värde kan inte ändras.