const ist die Abkürzung für constant, was ursprünglich unveränderlich und nicht leicht zu ändern bedeutet. In C++ wird es verwendet, um Variablen von eingebauten Typen, benutzerdefinierte Objekte, Memberfunktionen, Rückgabewerte und Funktionsparameter zu modifizieren.

C++ const ermöglicht die Angabe einer semantischen Einschränkung, die der Compiler durchsetzt, sodass der Programmierer dem Compiler mitteilen kann, dass ein Wert unverändert bleibt. Wenn es tatsächlich einen Wert gibt, der während der Programmierung unverändert bleibt, sollten Sie const explizit verwenden, damit Sie die Hilfe des Compilers erhalten.

1. const modifiziert Variablen gewöhnlicher Typen

const int  a = 7; 
int  b = a; // 正确
a = 8;       // 错误，不能改变

a ist als Konstante definiert, und a kann b zugewiesen werden, aber a kann nicht erneut zugewiesen werden. Das Zuweisen zu einer Konstante ist unzulässig, weil a vom Compiler als Konstante betrachtet wird und sein Wert nicht geändert werden darf.

Betrachten Sie nun die folgenden Operationen:

Beispiel

#include<iostream> using namespace std; int main(void) { const int a = 7; int *p = (int*)&a; *p = 8; cout<<a; system("pause"); return 0; }

Für die const-Variable a nehmen wir die Adresse der Variable, casten sie und weisen sie einem Zeiger auf int zu, verwenden dann *p = 8; um den Wert an der Adresse der Variable a neu zuzuweisen, und geben anschließend aus, um den Wert von a zu überprüfen.

Im untenstehenden Debug-Fenster können wir sehen, dass der Wert von a auf 8 geändert wurde, aber das Ausgabeergebnis immer noch 7 ist.

Am Ergebnis können wir sehen, dass der Compiler den Wert von a dann als den ursprünglich definierten Wert 7 ansieht, sodass Operationen auf const a die obige Situation erzeugen. Versuchen Sie daher niemals, einer const-Variable einen Wert zuzuweisen, da dies unerwartetes Verhalten hervorruft.

Wenn Sie nicht möchten, dass der Compiler die obigen Operationen auf const bemerkt, können wir das Schlüsselwort volatile vor const hinzufügen.

Das Schlüsselwort volatile ist das Gegenteil von const; es bedeutet veränderbar und leicht änderbar. Daher wird es nicht vom Compiler optimiert, und der Compiler wird seine Operationen an der Variable a nicht ändern.

Beispiel

#include<iostream> using namespace std; int main(void) { volatile const int a = 7; int *p = (int*)&a; *p = 8; cout<<a; system("pause"); return 0; }

Das Ausgabeergebnis ist 8, wie wir erwartet haben.

2. const modifiziert Zeigervariablen

Das Modifizieren von Zeigervariablen durch const hat die folgenden drei Fälle.

  • A: Wenn const das modifiziert, worauf der Zeiger zeigt, dann ist der Inhalt unveränderlich.
  • B: Wenn const den Zeiger modifiziert, dann ist der Zeiger unveränderlich.
  • C: Wenn const sowohl den Zeiger als auch das modifiziert, worauf er zeigt, dann sind sowohl der Zeiger als auch der Inhalt, auf den er zeigt, unveränderlich.

Für A:

const int *p = 8;

Dann kann der Inhalt 8, auf den der Zeiger zeigt, nicht geändert werden. Kurz gesagt: "links fixiert den Wert", weil const auf der linken Seite des *-Zeichens steht.

Für B:

int a = 8;
int* const p = &a;
*p = 9; // 正确
int  b = 7;
p = &b; // 错误

Beim const-Zeiger p kann die Speicheradresse, auf die er zeigt, nicht geändert werden, aber sein Inhalt kann geändert werden. Kurz gesagt: "rechts fixiert die Richtung", weil const auf der rechten Seite des *-Zeichens steht.

Für C:Es ist die Kombination aus A und B.

int a = 8;
const int * const  p = &a;

Zu diesem Zeitpunkt sind sowohl der Inhalt, auf den const p zeigt, als auch die Speicheradresse, auf die er zeigt, festgelegt und können nicht geändert werden.

Für die drei Fälle A, B und C fasse ich entsprechend den unterschiedlichen Positionen von const relativ zum *-Zeichen drei Merksätze zusammen, um das Erinnern zu erleichtern:"Links fixiert den Wert, rechts fixiert die Richtung, const modifiziert Unveränderliche."。

3. const-Parameterübergabe und Rückgabewerte von Funktionen

Für const, das Funktionsparameter modifiziert, kann es in drei Fälle unterteilt werden.

A: const modifiziert die Übergabe per Wert. Im Allgemeinen benötigt dieser Fall keine const-Modifizierung, weil die Funktion automatisch eine temporäre Variable erstellt, um den Argumentwert zu kopieren.

Beispiel

#include<iostream> using namespace std; void Cpf(const int a) { cout<<a; // ++a; ist falsch, a kann nicht geändert werden } int main(void) { Cpf(8); system("pause"); return 0; }

B: Wenn der const-Parameter ein Zeiger ist, kann er verhindern, dass der Zeiger versehentlich manipuliert wird.

Beispiel

#include<iostream> using namespace std; void Cpf(int *const a) { cout<<*a<<" "; *a = 9; } int main(void) { int a = 8; Cpf(&a); cout<<a; // a ist 9 system("pause"); return 0; }

C: Für die Parameterübergabe von benutzerdefinierten Typen wird ein temporäres Objekt benötigt, um den Parameter zu kopieren. Das Erstellen des temporären Objekts erfordert den Aufruf des Konstruktors, was Zeitverschwendung ist. Daher verwenden wir const plus Übergabe per Referenz.

Darüber hinaus verwenden wir für gängige eingebaute Typen wie int und double keine Referenzübergabe.

Beispiel

#include<iostream> using namespace std; class Test { public: Test(){} Test(int _m):_cm(_m){} int get_cm()const { return _cm; } private: int _cm; }; void Cmf(const Test& _tt) { cout<<_tt.get_cm(); } int main(void) { Test t(8); Cmf(t); system("pause"); return 0; }

Ergebnis ausgeben8。

Für const beim Modifizieren des Rückgabewerts einer Funktion.

Das Modifizieren von Rückgabewerten durch const wird in drei Fälle unterteilt.

A: Das Modifizieren des Rückgabewerts eines eingebauten Typs durch const hat denselben Effekt wie das Nichtmodifizieren.

Beispiel

#include<iostream> using namespace std; const int Cmf() { return 1; } int Cpf() { return 0; } int main(void) { int _m = Cmf(); int _n = Cpf(); cout<<_m<<" "<<_n; system("pause"); return 0; }

B: const modifiziert einen benutzerdefinierten Typ als Rückgabewert. In diesem Fall kann der zurückgegebene Wert nicht als lvalue verwendet werden; er kann nicht zugewiesen oder geändert werden.

C: const modifiziert den zurückgegebenen Zeiger oder die zurückgegebene Referenz. Ob ein Zeiger auf const zurückgegeben werden soll, hängt davon ab, was wir möchten, dass der Benutzer tut.

4. const modifiziert Klassenmemberfunktionen

Das Modifizieren einer Klassenmemberfunktion mit const soll verhindern, dass die Memberfunktion den Wert des aufgerufenen Objekts ändert. Wenn wir den Wert eines aufrufenden Objekts nicht ändern möchten, sollten alle Memberfunktionen als const-Memberfunktionen deklariert werden.

Hinweis:Das Schlüsselwort const kann nicht zusammen mit dem Schlüsselwort static verwendet werden, da das Schlüsselwort static statische Memberfunktionen modifiziert und statische Memberfunktionen keinen this-Zeiger enthalten, d. h., sie können nicht instanziiert werden. Eine const-Memberfunktion muss zu einer bestimmten Instanz gehören.

Die folgende Funktion get_cm()const; verwendet eine const-Memberfunktion:

Beispiel

#include<iostream> using namespace std; class Test { public: Test(){} Test(int _m):_cm(_m){} int get_cm()const { return _cm; } private: int _cm; }; void Cmf(const Test& _tt) { cout<<_tt.get_cm(); } int main(void) { Test t(8); Cmf(t); system("pause"); return 0; }

Wenn get_cm() den const-Modifizierer entfernt, dann geht der Compiler, obwohl das an Cmf übergebene const _tt den Wert des Objekts nicht ändert, dennoch davon aus, dass die Funktion den Wert des Objekts ändern wird. Daher sollten wir, wie gefordert, alle Funktionen, die den Objektinhalt nicht ändern müssen, als const-Memberfunktionen deklarieren.

Was, wenn eine Memberfunktion einen bestimmten Member des Objekts ändern möchte? In diesem Fall können wir das Schlüsselwort mutable verwenden, um diesen Member zu ändern. mutable bedeutet auch veränderbar und leicht veränderbar. Ein durch das Schlüsselwort mutable modifiziertes Member kann sich in einem ständigen Zustand der Veränderung befinden, wie im folgenden Beispiel.

Beispiel

#include<iostream> using namespace std; class Test { public: Test(int _m,int _t):_cm(_m),_ct(_t){} void Kf()const { ++_cm; // Falsch ++_ct; // Richtig } private: int _cm; mutable int _ct; }; int main(void) { Test t(8,7); return 0; }

Hier, in Kf()const, ändern wir den Wert von _ct durch ++_ct;, aber das Ändern von _cm durch ++_cm verursacht einen Fehler, weil ++_cm nicht mit mutable modifiziert wird.

Adresse des Originalartikels: https://www.cnblogs.com/Forever-Kenlen-Ja/p/3776991.html