Wie überlade ich den Inkrementoperator () für Pre- und Post-Inkrement in C?

Überladen für Pre- und Post-Inkrement: Mehrdeutigkeit auflösen

Operatoren können in C überladen werden, um die Funktionalität integrierter Operatoren für zu erweitern benutzerdefinierte Typen. Ein häufiger Anwendungsfall ist die Überlastung des Inkrementoperators ( ) sowohl für Vor- als auch für Nachinkrementoperationen. Dies zu erreichen, ohne auf Mehrdeutigkeitsprobleme zu stoßen, ist jedoch eine Herausforderung.

Anfangsansatz: Gleicher Rückgabetyp

Im bereitgestellten Codeausschnitt überlastet der erste Versuch den Operator mit Gleicher Rückgabetyp (int) für Pre- und Post-Inkrement. Dieser Ansatz schlägt jedoch aus folgenden Gründen fehl:

• Funktionsüberladung basierend auf dem Rückgabetyp:
  C erlaubt keine Funktionsüberladung basierend ausschließlich auf dem Rückgabetyp. Während unterschiedliche Argumenttypen zwischen Überladungen unterscheiden können, reichen unterschiedliche Rückgabetypen allein nicht aus.
• Mehrdeutigkeit bei der Überladungsauflösung:
  Beim Aufruf eines SampleObject kann der Compiler nicht bestimmen, auf welche Überladung zugegriffen werden soll verwenden, da beide denselben Typ zurückgeben. Diese Mehrdeutigkeit verursacht einen Fehler bei der Kompilierung.

Lösung: Überladen mit Dummy-Argument

Um diese Mehrdeutigkeit zu beheben, wird die Postfix-Version des Operators mit überladen ein Dummy-int-Parameter. Mit dieser Änderung werden zwei Ziele erreicht:

• Unterscheidung von Postfix-Überladung:
  Der Dummy-Parameter stellt eine eindeutige Signatur für die Postfix-Überladung bereit und unterscheidet sie von der Präfix-Überladung.
• Erhaltung der Inkrementierungslogik:
  Die Präfixüberladung bleibt unverändert, erhöht die aktuelle Instanz und gibt einen Verweis darauf zurück. Die Postfix-Überladung erstellt eine temporäre Kopie der aktuellen Instanz, erhöht sie und gibt den Wert vor der Erhöhung zurück.

Codebeispiel:

<code class="cpp">#include <iostream>

class CSample {
 public:
  int m_iValue;     // just to directly fetch inside main()
  CSample() : m_iValue(0) {}
  CSample(int val) : m_iValue(val) {}

  // Overloading ++ for Pre-Increment
  CSample& operator++() {
    ++m_iValue;
    return *this;
  }

  // Overloading ++ for Post-Increment
  CSample operator++(int) {
    CSample tmp(*this);
    operator++(); // prefix-increment this instance
    return tmp;   // return value before increment
  }
};

int main() {
  CSample obj1(5);
  std::cout << obj1.m_iValue << std::endl; // Output: 5

  // Pre-Increment
  ++obj1;
  std::cout << obj1.m_iValue << std::endl; // Output: 6

  // Post-Increment
  CSample obj2 = obj1++;
  std::cout << obj2.m_iValue << std::endl; // Output: 6
  std::cout << obj1.m_iValue << std::endl; // Output: 7

  return 0;
}</code>

Indem wir den Operator mit einem Dummy-Argument für die Postfix-Version überladen, lösen wir effektiv die Mehrdeutigkeit und ermöglichen sowohl das Verhalten vor als auch nach dem Inkrementieren für benutzerdefinierte Typen in C.

Das obige ist der detaillierte Inhalt vonWie überlade ich den Inkrementoperator () für Pre- und Post-Inkrement in C?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!