In diesem Artikel werden die verschiedenen Funktionen des const-Schlüsselwort was in zu finden ist C++ sind besprochen. Wann immer const-Schlüsselwort wird mit jeder Methode(), Variable, Zeigervariable , und mit dem Objekt einer Klasse wird dies verhindert Objekt/Methode()/Variable um den Wert seiner Datenelemente zu ändern.

Konstante Variablen:

Für die Deklaration und Initialisierung der Konstantvariablen gelten bestimmte Regeln:

• Der const-Variable darf zum Zeitpunkt der Zuweisung nicht uninitialisiert bleiben.
• Es kann nirgendwo im Programm ein Wert zugewiesen werden.
• Der Konstantenvariablen musste zum Zeitpunkt der Deklaration der Konstantenvariablen ein expliziter Wert bereitgestellt werden.

Nachfolgend finden Sie das C++-Programm zur Veranschaulichung des oben genannten Konzepts:

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

Der Fehler lag an einer fehlerhaften Deklaration : Wenn Sie versuchen, die Variable const zu initialisieren, ohne einen expliziten Wert zuzuweisen, wird ein Kompilierzeitfehler (CTE) generiert.

Const-Schlüsselwort mit Zeigervariablen:

Zeiger können mit einem const-Schlüsselwort deklariert werden. Es gibt also drei Möglichkeiten, ein const-Schlüsselwort mit einem Zeiger zu verwenden:

Wenn das Zeigervariable zeigt auf einen konstanten Wert :

Syntax:

  const data_type* var_name;>

Nachfolgend finden Sie das C++-Programm zur Implementierung des oben genannten Konzepts:

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

Erläuterung: Im obigen Fall sind i und j zwei Zeigervariablen, die auf einen Speicherort vom Typ const int und char zeigen, aber der an diesen entsprechenden Orten gespeicherte Wert kann wie oben beschrieben geändert werden.

Ansonsten , Die Es erscheint folgender Fehler: Wenn wir versuchen, den Wert der const-Variablen zu ändern.

Wenn die konstante Zeigervariable auf den Wert zeigt :

Syntax:

  data_type* const     var_name;>

Nachfolgend finden Sie ein Beispiel zur Veranschaulichung des oben genannten Konzepts:

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

Erläuterung: Die Werte, die in den entsprechenden Zeigervariablen i und j gespeichert sind, sind änderbar, aber die von Konstantenzeigervariablen angegebenen Speicherorte, an denen die entsprechenden Werte von x und y gespeichert sind, sind nicht änderbar.

Andernfalls wird der folgende Fehler angezeigt: Die Zeigervariablen sind konstant und zeigen auf die Speicherorte, an denen x und y gespeichert sind. Wenn wir versuchen, den Adressspeicherort zu ändern, tritt ein Fehler auf.

Wenn ein const-Zeiger auf eine const-Variable zeigt :

Syntax:

  const data_type* const var_name;>

Nachfolgend finden Sie das C++-Programm zur Veranschaulichung des oben genannten Konzepts:

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

Erläuterung: Hier zeigt die const-Zeigervariable auf die const-Variable. Daher ist es Ihnen nicht gestattet, die Konstante zu ändern Zeigervariable(*P) noch der Wert, der an der Stelle gespeichert ist, auf die er verweist Zeigervariable(*P).

Andernfalls wird der folgende Fehler angezeigt: Hier sind sowohl die Zeigervariable als auch die Orte, auf die die Zeigervariable zeigt, konstant. Wenn also eine davon geändert wird, wird der folgende Fehler angezeigt:

allgemeine Schutzverletzung

Die Übergabe eines konstanten Argumentwerts an einen nicht konstanten Parameter einer Funktion führt zu einem Fehler : Die Übergabe eines const-Argumentwerts an einen nicht-const-Parameter einer Funktion ist ungültig und führt zu einem Fehler bei der Kompilierung.

Nachfolgend finden Sie das C++-Programm zur Veranschaulichung des oben genannten Konzepts:

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

Ausgabe: Der Fehler bei der Kompilierung erscheint, als ob der konstante Wert an ein beliebiges nicht konstantes Argument der Funktion übergeben wird. Dann erscheint der folgende Fehler bei der Kompilierung:

Darüber hinaus führt die Übergabe des const-Zeigers zu keinem Fehler, da ein anderer Zeiger erstellt wird, der ebenfalls auf denselben Speicherort zeigt.

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

Der Code wird fehlerfrei ausgeführt und die beiden Zeiger haben unterschiedliche Adressen.

Zusammenfassend lässt sich die obige Diskussion wie folgt abschließen:

1. int-Wert = 5; // nicht konstanter Wert

2. const int *ptr_1 = &value; // ptr_1 zeigt auf einen konstanten int-Wert, also ist dies ein Zeiger auf einen konstanten Wert.

3. int *const ptr_2 = &value; // ptr_2 zeigt auf ein int, also ist dies ein konstanter Zeiger auf einen nicht konstanten Wert.

4. const int *const ptr_3 = &value; // ptr_3 zeigt auf einen konstanten int-Wert, daher ist dies ein konstanter Zeiger auf einen konstanten Wert.

Konstante Methoden:

Wie Mitgliedsfunktionen und Mitgliedsfunktionsargumente können auch die Objekte einer Klasse als deklariert werden const . Ein als const deklariertes Objekt kann nicht geändert werden und kann daher nur const-Memberfunktionen aufrufen, da diese Funktionen sicherstellen, dass das Objekt nicht geändert wird.

Syntax:

const Class_Name Object_name;>

• Wenn eine Funktion als const deklariert ist, kann sie für jeden Objekttyp aufgerufen werden, sowohl für const-Objekte als auch für nicht-const-Objekte.
• Immer wenn ein Objekt als const deklariert wird, muss es zum Zeitpunkt der Deklaration initialisiert werden. Allerdings ist die Objektinitialisierung bei der Deklaration nur mit Hilfe von Konstruktoren möglich.

Es gibt zwei Möglichkeiten, a konstante Funktion Erklärung:

Gewöhnliche const-function-Deklaration :

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

Eine konstante Memberfunktion der Klasse :

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

Unten sehen Sie das Beispiel einer konstanten 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>

Der folgende Fehler tritt auf, wenn Sie versuchen, die nicht konstante Funktion von einem konstanten Objekt aus aufzurufen

Wie viele Mission-Impossible-Filme gibt es?

Konstante Funktionsparameter und Rückgabetyp :

Eine Funktion()-Parameter und Der Rückgabetyp der Funktion() kann als Konstante deklariert werden. Konstante Werte können nicht geändert werden, da ein solcher Versuch einen Fehler bei der Kompilierung erzeugt.

Nachfolgend finden Sie das C++-Programm zur Implementierung des oben genannten Ansatzes:

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

Erläuterung: Der folgende Fehler wird angezeigt, wenn die Anweisung y = 6 in der Funktion foo() verwendet wird:

• // y = 6; Ein konstanter Wert kann nicht geändert oder modifiziert werden.

Für const-Rückgabetyp : Der Rückgabetyp der Funktion() ist const und gibt daher einen konstanten Ganzzahlwert an uns zurück. Nachfolgend finden Sie das C++-Programm zur Implementierung des oben genannten Ansatzes:

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

Der zurückgegebene Wert ist ein konstanter Wert.

Außerdem stellt die Übergabe einer Konstanten- oder Nicht-Konstanten-Variable an die Funktion kein wesentliches Problem dar, solange wir sie als Wert übergeben, da eine neue Kopie erstellt wird. Das Problem entsteht, wenn wir versuchen, die konstante Variable als Referenz an die Funktion zu übergeben, deren Parameter nicht konstant ist. Dadurch wird das const-Qualifikationsmerkmal ignoriert, was zu folgendem Fehler führt:

Für const-Rückgabetyp und const-Parameter : Hier sind sowohl der Rückgabetyp als auch der Parameter der Funktion vom Typ const. Nachfolgend finden Sie das C++-Programm zur Implementierung des oben genannten Ansatzes:

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

Erläuterung: Hier können sowohl konstante als auch nicht konstante Werte als konstante Parameter an die Funktion übergeben werden, wir dürfen dann jedoch den Wert einer übergebenen Variablen nicht ändern, da der Parameter konstant ist. Andernfalls werden wir mit dem folgenden Fehler konfrontiert:

// y=9; Es wird ein Fehler bei der Kompilierung ausgegeben, da y const var ist und sein Wert nicht geändert werden kann.