Comment surcharger l'opérateur d'incrémentation ( ) pour le pré et le post-incrément en C ?

Surcharge pour les incréments pré et post : résolution de l'ambiguïté

Les opérateurs peuvent être surchargés en C pour étendre les fonctionnalités des opérateurs intégrés pour types définis par l'utilisateur. Un cas d'utilisation courant consiste à surcharger l'opérateur d'incrémentation ( ) pour les opérations de pré- et de post-incrémentation. Cependant, y parvenir sans rencontrer de problèmes d'ambiguïté est un défi.

Approche initiale : même type de retour

Dans l'extrait de code fourni, la tentative initiale surcharge l'opérateur avec le même type de retour (int) pour le pré- et le post-incrémentation. Cependant, cette approche échoue pour les raisons suivantes :

• Surcharge de fonctions basée sur le type de retour :
  C n'autorise pas la surcharge de fonctions basée uniquement sur le type de retour. Bien que différents types d'arguments puissent faire la distinction entre les surcharges, différents types de retour ne suffisent pas à eux seuls.
• Ambiguïté dans la résolution de surcharge :
  Lors de l'appel d'un SampleObject, le compilateur ne peut pas déterminer quelle surcharge utiliser. utiliser car les deux renvoient le même type. Cette ambiguïté provoque une erreur de compilation.

Solution : surcharge avec un argument factice

Pour résoudre cette ambiguïté, la version postfix de l'opérateur est surchargée avec un paramètre int factice. Cette modification atteint deux objectifs :

• Distinguer la surcharge de postfix :
  Le paramètre factice fournit une signature unique pour la surcharge de postfix, la différenciant de la surcharge de préfixe.
• Préservation de la logique d'incrément :
  La surcharge de préfixe reste inchangée, incrémentant le courant instance et en renvoyant une référence à celle-ci. La surcharge postfix crée une copie temporaire de l'instance actuelle, l'incrémente et renvoie la valeur avant l'incrément.

Exemple de code :

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

En surchargeant l'opérateur avec un argument factice pour la version postfix, nous résolvons efficacement l'ambiguïté et activons le comportement avant et après l'incrémentation pour les types personnalisés en C .

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!