In dit artikel worden de verschillende functies van de const-trefwoord waarin gevonden wordt C++ komen aan bod. Wanneer dan ook const-trefwoord is gekoppeld aan elke methode(), variabele, pointervariabele , en met het object van een klasse voorkomt het dat specifieke object/methode()/variabele om de waarde van de gegevensitems te wijzigen.

Constante variabelen:

Er zijn een bepaalde reeks regels voor de declaratie en initialisatie van de constante variabelen:

• De const-variabele kan niet ongeïnitialiseerd blijven op het moment van de opdracht.
• Er kan nergens in het programma waarde aan worden toegekend.
• Er moest een expliciete waarde aan de constante variabele worden gegeven op het moment dat de constante variabele werd gedeclareerd.

Hieronder vindt u het C++-programma om het bovenstaande concept te demonstreren:

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

De fout die werd geconfronteerd vanwege een foutieve aangifte : Als u de const-variabele probeert te initialiseren zonder een expliciete waarde toe te wijzen, wordt er een compilatiefout (CTE) gegenereerd.

Const-trefwoord met aanwijzervariabelen:

Pointers kunnen worden gedeclareerd met een const-trefwoord. Er zijn dus drie mogelijke manieren om een ​​const-trefwoord met een pointer te gebruiken, namelijk:

Wanneer de pointervariabele wijst naar een const-waarde :

Syntaxis:

  const data_type* var_name;>

Hieronder vindt u het C++-programma om het bovenstaande concept te implementeren:

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

Uitleg: Hier in het bovenstaande geval zijn i en j twee pointervariabelen die verwijzen naar een geheugenlocatie const int-type en char-type, maar de waarde die op deze corresponderende locaties is opgeslagen, kan worden gewijzigd zoals we hierboven hebben gedaan.

Anders , de volgende foutmelding verschijnt: Als we proberen de waarde van de const-variabele te wijzigen.

ronde wiskunde Java

Wanneer de const pointervariabele naar de waarde verwijst :

Syntaxis:

  data_type* const     var_name;>

Hieronder ziet u het voorbeeld om het bovenstaande concept te demonstreren:

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

Uitleg: De waarden die zijn opgeslagen in de overeenkomstige pointervariabelen i en j zijn wijzigbaar, maar de locaties die worden aangegeven door const-pointervariabelen waar de overeenkomstige waarden van x en y zijn opgeslagen, zijn niet wijzigbaar.

Anders verschijnt de volgende foutmelding: De pointervariabelen zijn const en wijzen naar de locaties waar de x en y zijn opgeslagen. Als we proberen de adreslocatie te wijzigen, zullen we de fout tegenkomen.

Wanneer de const-aanwijzer naar een const-variabele verwijst :

Syntaxis:

  const data_type* const var_name;>

Hieronder vindt u het C++-programma om het bovenstaande concept te demonstreren:

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

Uitleg: Hier wijst de const-pointervariabele naar de const-variabele. U mag de const. dus ook niet wijzigen pointervariabele(*P) noch de waarde die is opgeslagen op de locatie die daardoor wordt aangegeven pointervariabele(*P).

Anders verschijnt de volgende foutmelding: Hier zijn zowel de pointervariabele als de locaties die door de pointervariabele worden aangewezen constant, dus als een van deze wordt gewijzigd, verschijnt de volgende foutmelding:

Geef de const-argumentwaarde door aan een niet-const-parameter van een functieoorzaakfout : Het doorgeven van de const-argumentwaarde aan een niet-const-parameter van een functie is niet geldig en geeft u een compileerfout.

Hieronder vindt u het C++-programma om het bovenstaande concept te demonstreren:

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

Uitgang: De compileerfout die verschijnt alsof de const-waarde wordt doorgegeven aan een niet-const-argument van de functie, waarna de volgende compileerfout verschijnt:

Bovendien zal het doorgeven van de const-pointer niet resulteren in een fout, omdat er een andere pointer wordt gemaakt die ook naar dezelfde geheugenlocatie verwijst.

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

De code wordt zonder fouten uitgevoerd en de twee pointers hebben verschillende adressen.

xvideoservicedief ubuntu 14.04 downloaden

Kort samengevat kan de bovenstaande discussie als volgt worden afgerond:

1. int-waarde = 5; // niet-const-waarde

2. const int *ptr_1 = &waarde; // ptr_1 verwijst naar een const int-waarde, dus dit is een verwijzing naar een const-waarde.

3. int *const ptr_2 = &waarde; // ptr_2 verwijst naar een int, dus dit is een const-aanwijzer naar een niet-const-waarde.

4. const int *const ptr_3 = &waarde; // ptr_3 verwijst naar een const int-waarde, dus dit is een const-pointer naar een const-waarde.

Constante methoden:

Net als lidfuncties en lidfunctieargumenten kunnen de objecten van een klasse ook worden gedeclareerd als const . Een object dat als const is gedeclareerd, kan niet worden gewijzigd en kan daarom alleen const-lidfuncties aanroepen, aangezien deze functies ervoor zorgen dat het object niet wordt gewijzigd.

Syntaxis:

Java-generator voor willekeurige getallen

const Class_Name Object_name;>

• Wanneer een functie als const wordt gedeclareerd, kan deze voor elk type object worden aangeroepen, zowel const-objecten als niet-const-objecten.
• Telkens wanneer een object als const wordt gedeclareerd, moet het op het moment van declaratie worden geïnitialiseerd. De objectinitialisatie tijdens het declareren is echter alleen mogelijk met behulp van constructors.

Er zijn twee manieren om a constante functie verklaring:

Gewone const-functieverklaring :

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

Een const-lidfunctie van de klasse :

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

Hieronder ziet u een voorbeeld van een constante functie:

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

De volgende fout treedt op als u de niet-const-functie probeert aan te roepen vanuit een const-object

Constante functieparameters en retourtype :

Een functie()-parameters en return type function() kan als constant worden gedeclareerd. Constante waarden kunnen niet worden gewijzigd, aangezien een dergelijke poging een compilatiefout zal genereren.

Hieronder vindt u het C++-programma om de bovenstaande aanpak te implementeren:

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

Uitleg: De volgende foutmelding wordt weergegeven als de instructie y = 6 wordt gebruikt in de functie foo():

• // j = 6; een const-waarde kan niet worden gewijzigd of aangepast.

Voor const-retourtype : Het retourneringstype van de functie() is const en retourneert dus een geheel getal const-waarde naar ons. Hieronder vindt u het C++-programma om de bovenstaande aanpak te implementeren:

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

De geretourneerde waarde zal een constante waarde zijn.

Er is ook geen substantieel probleem bij het doorgeven van de const- of niet-const-variabele aan de functie, zolang we deze op waarde doorgeven omdat er een nieuwe kopie wordt gemaakt. Het probleem doet zich voor wanneer we proberen de constante variabele door te geven door te verwijzen naar de functie waarvan de parameter niet-constant is. Hierbij wordt de const-kwalificatie genegeerd, wat leidt tot de volgende fout:

Voor const retourneert type en const parameter : Hier zijn zowel het retourtype als de parameter van de functie van const-typen. Hieronder vindt u het C++-programma om de bovenstaande aanpak te implementeren:

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

Uitleg: Hier kunnen zowel const- als niet-const-waarden worden doorgegeven als de const-parameter aan de functie, maar we mogen vervolgens de waarde van een doorgegeven variabele niet wijzigen omdat de parameter const is. Anders worden we geconfronteerd met de onderstaande fout:

// y=9; het geeft de compileerfout omdat y const var is en de waarde ervan kan niet worden gewijzigd.