C++-Syntaxfehler: Überladene Operatoren müssen Mitgliedsfunktionen sein. Wie kann man ihn beheben?

C++ ist eine beliebte Programmiersprache mit leistungsstarken objektorientierten Programmierfunktionen. Beim Programmieren in C++ können manchmal Syntaxfehler auftreten. In diesem Artikel wird ein häufiger Fehler besprochen: „Der überladene Operator muss eine Mitgliedsfunktion sein“ und eine Lösung für das Problem bereitgestellt werden.

In C++ können Operatoren überladen werden, um verschiedene Operationen mithilfe von Objekten benutzerdefinierter Klassen auszuführen. Beispielsweise kann der „+“-Operator überladen werden, um eine Addition zwischen zwei benutzerdefinierten Klassenobjekten zu implementieren. Das Überladen von Operatoren kann durch Mitgliedsfunktionen oder globale Funktionen implementiert werden.

Wenn wir eine mit einem Operator überladene Funktion deklarieren, müssen wir angeben, ob es sich um eine Mitgliedsfunktion oder eine globale Funktion handelt. Bei Verwendung von Memberfunktionen muss die mit dem Operator überladene Funktion eine Memberfunktion der Klasse werden. Manchmal verwenden wir jedoch zum Überladen von Operatoren eine Nicht-Member-Funktion und erhalten dann die Fehlermeldung „Der überladene Operator muss eine Member-Funktion sein.“

Um diesen Fehler zu beheben, können wir die vom Operator überladene Funktion in eine Mitgliedsfunktion der Klasse konvertieren.

Angenommen, wir möchten den „+“-Operator überladen, um die Additionsoperation zwischen zwei benutzerdefinierten Klassenobjekten zu implementieren. Unsere Klasse heißt „Number“ und verfügt über zwei private Mitgliedsvariablen num1 und num2. Mit dem folgenden Code können wir eine mit einem Operator überladene Funktion deklarieren:

Number operator+(const Number& num1, const Number& num2) {
  Number sum;
  sum.num1 = num1.num1 + num2.num1;
  sum.num2 = num1.num2 + num2.num2;
  return sum;
}

In diesem Code verwenden wir eine globale Funktion, um den „+“-Operator zu überladen. Das ist falsch, weil wir es in eine Mitgliedsfunktion konvertieren müssen. Dazu müssen wir es als Mitgliedsfunktion der Number-Klasse deklarieren und den „+“-Operator als Funktionsnamen verwenden. Der modifizierte Code sieht so aus:

class Number {
public:
  Number operator+(const Number& num) {
    Number sum;
    sum.num1 = num1 + num.num1;
    sum.num2 = num2 + num.num2;
    return sum;
  }
  
private:
  int num1;
  int num2;
};

In diesem modifizierten Code deklarieren wir die überladene Operatorfunktion als Mitgliedsfunktion der Number-Klasse und verwenden den „+“-Operator als Funktionsnamen. Jetzt können wir die Additionsoperation zwischen zwei Number-Objekten mit dem folgenden Code durchführen:

Number num1;
num1.num1 = 1;
num1.num2 = 2;

Number num2;
num2.num1 = 3;
num2.num2 = 4;

Number sum = num1 + num2;

Auf diese Weise können wir den „+“-Operator erfolgreich überladen und die Additionsoperation zwischen zwei Number-Objekten durchführen.

Kurz gesagt, in C++ müssen überladene Operatoren mithilfe von Mitgliedsfunktionen implementiert werden. Wenn der aktuelle Code eine Nicht-Member-Funktion zum Implementieren der Operatorüberladung verwendet, können wir zur Behebung dieses Problems diese in eine Member-Funktion konvertieren, die Funktion als Member-Funktion der Klasse deklarieren und den Operator als Funktionsnamen verwenden.

Das obige ist der detaillierte Inhalt vonC++-Syntaxfehler: Überladene Operatoren müssen Mitgliedsfunktionen sein. Wie kann man ihn beheben?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!