Das Schlüsselwort const in der Funktionsdeklaration von Klassen in C++

1. das Schlüsselwort const in der Funktionsdeklaration von Klassen in C++
2. das Verhalten einer Member-Funktion in C++
3. das Verhalten einer const Member-Funktion in C++
4. Abschluss

In C++ definiert das Schlüsselwort const jene Werte, die sich während der Programmausführung nicht ändern und konstant bleiben. Das klingt ziemlich einfach für Variablen und die Daten, die sie enthalten.

Aber wie kann eine Funktion als konstant deklariert werden und was muss in einer Funktion unverändert bleiben? Wir werden all diese Fragen und noch viel mehr in diesem Artikel beantworten, also lies weiter!

Beachten Sie, dass die Funktionen, die wir hier betrachten, diejenigen sind, die zu einer Klasse gehören, also Member-Funktionen.

das Schlüsselwort const in der Funktionsdeklaration von Klassen in C++

Bevor wir in die eigentliche Diskussion eintauchen, lassen Sie uns die Problemstellung richtig verstehen.

Wir wissen bereits, dass eine Klasse Datenmember und Memberfunktionen haben kann. Diese Member-Funktionen werden normalerweise innerhalb der Klasse wie folgt deklariert:

class Demo  // class
{
 public:
  int x;
  int showDemo();  // member function declaration
}

Hier gehört die Member-Funktion showDemo() zur Klasse Demo. Aber was bedeutet es, wenn wir so am Ende der Member-Funktion const hinzufügen -

class Demo  // class
{
 public:
  int x;
  int showDemo() const;  // const member function declaration
}

Sehen wir uns zuerst an, wie sich eine Member-Funktion normalerweise in C++ verhält, um dies zu verstehen.

das Verhalten einer Member-Funktion in C++

Sehen Sie sich den unten angegebenen Code an. Hier definieren wir zunächst eine Klasse namens Demo mit einem Datenmember chocolates, dessen Wert auf 2, gesetzt ist, und einer Member-Funktion Desert().

Innerhalb der Member-Funktion drucken wir zusammen mit einer Willkommens-Anweisung den ursprünglichen Wert des Daten-Members, chocolates, und erhöhen diesen Wert dann um eins. Außerdem geben wir in der nächsten Anweisung den inkrementierten Wert von chocolates aus.

Schließlich erstellen wir ein Objekt demo und rufen die Member-Funktion Desert() aus dem main-Block auf. Außerdem drucken wir den Wert von chocolates mit dem Objekt demo und dem dot-Operator.

#include <iostream>
using namespace std;

class Demo {
 public:
  int chocolates = 2;

 public:
  void Desert()  // member function
  {
    cout << "Hello Chocolates" << endl;
    cout << "Before change: " << chocolates << endl;
    chocolates++;
    cout << "After change: " << chocolates << endl;
  }
};

int main() {
  Demo demo;
  demo.Desert();
  cout << demo.chocolates << endl;
}

Ausgang:

Hello Chocolates
Before change: 2
After change: 3
3

Sie können hier sehen, dass wir den Wert des Datenmembers chocolates innerhalb der Memberfunktion geändert haben. Um die Änderung genauer hervorzuheben, drucken wir den Wert dieser Variablen auch aus dem Haupt-Block, aber wir erhalten immer noch den aktualisierten Wert, nämlich 3.

Dieses Beispiel impliziert also, dass wir irgendwie eine normale Elementfunktion verwenden können, um das Objekt zu ändern.

Hier haben wir nur eine Klasse und ein Objekt. Beim Arbeiten mit vielen Klassen und Objekten besteht jedoch eine hohe Wahrscheinlichkeit, dass versehentlich Änderungen an einem Objekt vorgenommen werden.

Um dies zu vermeiden, verwenden wir die Member-Funktion const von C++.

das Verhalten einer const Member-Funktion in C++

Sehen Sie sich das unten angegebene Beispiel an. Dieser Code ist derselbe wie der vorherige, außer dass wir diesmal das Schlüsselwort const nach der Member-Funktion setzen.

#include <iostream>
using namespace std;

class Demo {
 public:
  int chocolates = 2;

 public:
  void Desert() const  // const member function
  {
    cout << "Hello Chocolates" << endl;
    cout << "Before change: " << chocolates << endl;
    chocolates++;
    cout << "After change: " << chocolates << endl;
  }
};

int main() {
  Demo demo;
  demo.Desert();
  cout << demo.chocolates << endl;
}

Ausgang:

In member function 'void Demo::Desert() const':
error: increment of member 'Demo::chocolates' in read-only object
   13 |             chocolates++;
      |             ^~~~~~~~~~

Sie können sehen, wie sich die Ausgabe ändert, indem Sie die Elementfunktion zu einer Konstanten machen. Diesmal wird der Wert von chocolates nicht erhöht und wir erhalten eine Fehlermeldung.

Dieses Beispiel impliziert also, dass wir eine Member-Funktion const nicht verwenden können, um das Objekt in irgendeiner Weise zu ändern.

Durch die beiden obigen Vergleiche von Memberfunktionen schließen wir, dass die Verwendung von const in solchen Funktionsdeklarationen impliziert, dass es keine Änderung in irgendeinem Klassenmember geben wird. Wenn wir einer Methode const hinzufügen, zeigt der this-Zeiger auf das const-Objekt, und daher können wir kein Datenelement ändern.

Nach allem, was wir gelernt haben, können wir sagen, dass wir die Elementfunktionen const verwenden, um die Änderung eines Objekts zu vermeiden. Aber dann fragen Sie sich vielleicht: Wozu dient ein const-Objekt?

Wenn wir ein Objekt als const deklarieren, kann es nur die Member-Funktionen const aufrufen. Das liegt daran, dass ein const-Objekt nicht modifiziert werden kann, und diese Nichtveränderung wird nur von const-Memberfunktionen versprochen.

Sehen Sie sich das Beispiel unten an.

Innerhalb der Klasse Desert haben wir zwei Member-Funktionen, desert() und desert() const. Dann definieren wir innerhalb des main-Blocks zwei Objekte, d, und ein konstantes Objekt, dd.

Beachten Sie einige wichtige Punkte zu diesem Beispiel:

1. Wir haben zwei Elementfunktionen mit demselben Namen. Der einzige Unterschied besteht darin, dass eine davon eine const-Elementfunktion ist.
2. Wir haben zwei Objekte, von denen eines ein konstantes Objekt ist.
3. Wir rufen die Member-Funktion desert() von beiden Objekten auf, ohne anzugeben, welches Objekt welche Funktion aufruft.

#include <iostream>
using namespace std;

class Desert {
 private:
  int cakes;

 public:
  void desert() { cout << "The first desert function." << endl; }

  void desert() const  // the const member function
  {
    cout << "The second const desert function." << endl;
  }
};

int main() {
  Desert d;              // object of class
  const Desert& dd = d;  // constant object of class
  d.desert();
  dd.desert();
}

Ausgang:

The first desert function.
The second const desert function.

Die Ausgabe zeigt deutlich, dass die normale Elementfunktion desert() automatisch vom normalen Objekt d aufgerufen wurde. Dagegen wird die Member-Funktion const, desert() const, automatisch vom const-Objekt dd aufgerufen.

Die Ausgabe ändert sich, wenn wir das Schlüsselwort const aus dem Objekt entfernen.

int main() {
  Desert d;        // object of class
  Desert& dd = d;  // remove the constant keyword
  d.desert();
  dd.desert();
}

Ausgang:

The first desert function.
The first desert function.

Dieses Mal rufen beide Objekte die erste Funktion auf. Dies beweist, dass ein const-Objekt eine const-Member-Funktion aufruft.

Beachten Sie, dass dies nicht bedeutet, dass wir keine Member-Funktion const für ein nicht konstantes Objekt aufrufen können. Eine Nicht-const-Funktion kann jedoch nur von Nicht-const-Objekten aufgerufen werden.

So weit, so gut, aber es gibt einen Ausnahmefall. Wenn wir den Quantifizierer mutable mit einem beliebigen Datenelement der Klasse verwenden, können wir das Objekt sogar in einer const-Methode modifizieren.

Sehen Sie sich dieses Beispiel an.

#include <iostream>
using namespace std;

class Demo {
 public:
  mutable int chocolates = 2;  // mutable quantifier
 public:
  void Desert() const  // const member function
  {
    cout << "Hello Chocolates" << endl;
    cout << "Before change: " << chocolates << endl;
    chocolates++;
    cout << "After change: " << chocolates << endl;
  }
};

int main() {
  Demo demo;
  demo.Desert();
  cout << demo.chocolates << endl;
}

Ausgang:

Hello Chocolates
Before change: 2
After change: 3
3

Jetzt erhalten wir dieses Mal keinen Fehler wie zuvor, weil wir den Quantifizierer veränderlich mit dem Datenelement Schokolade verwenden. Dies ist oft hilfreich, wenn wir zählen möchten, wie oft eine Methode aufgerufen wird.

Hier dreht sich alles um eine const Member-Funktion in C++. Je mehr Sie mit den Beispielen spielen und hier und da kleine Änderungen vornehmen, desto mehr Klarheit gewinnen Sie!

Um mehr über const in C++ zu erfahren, lesen Sie diese Dokumentation.

Abschluss

In diesem Artikel haben wir die Konzepte von const-Elementfunktionen von C++ besprochen. Eine const-Mitgliedsfunktion stellt sicher, dass ein Objekt nicht versehentlich geändert wird, und wir können sie sowohl mit const- als auch mit Nicht-const-Objekten verwenden.

Ein const-Objekt kann jedoch nur eine const-Member-Funktion widerrufen. Außerdem kann die Verwendung des Schlüsselworts mutable mit den Datenelementen das übliche Verhalten der Elementfunktion const ändern und wird normalerweise für Zählzwecke verwendet.