Surcharge d'opérateurs d'incrémentation et de décrémentation (C++)

Les opérateurs d'incrémentation et de décrémentation appartiennent à une catégorie spéciale car chacun comporte deux variantes :

• Incrémentation préfixée et incrémentation suffixée

• Décrémentation préfixée et décrémentation suffixée

Lorsque vous écrivez des fonctions d'opérateur surchargées, il peut être utile d'implémenter des versions distinctes des versions préfixées et suffixées de ces opérateurs. Pour faire la distinction entre les deux, la règle suivante est observée : la forme de préfixe de l’opérateur est déclarée exactement de la même façon que tout autre opérateur unaire ; le formulaire postfix accepte un argument supplémentaire de type int.

Remarque

Lors de la spécification d’un opérateur surchargé pour la forme postfix de l’opérateur d’incrémentation ou de décrémentation, l’argument supplémentaire doit être de type int; la spécification d’un autre type génère une erreur.

L'exemple suivant indique comment définir les opérateurs d'incrémentation et de décrémentation préfixés et suffixés pour la classe Point :

// increment_and_decrement1.cpp
class Point
{
public:
   // Declare prefix and postfix increment operators.
   Point& operator++();       // Prefix increment operator.
   Point operator++(int);     // Postfix increment operator.

   // Declare prefix and postfix decrement operators.
   Point& operator--();       // Prefix decrement operator.
   Point operator--(int);     // Postfix decrement operator.

   // Define default constructor.
   Point() { _x = _y = 0; }

   // Define accessor functions.
   int x() { return _x; }
   int y() { return _y; }
private:
   int _x, _y;
};

// Define prefix increment operator.
Point& Point::operator++()
{
   _x++;
   _y++;
   return *this;
}

// Define postfix increment operator.
Point Point::operator++(int)
{
   Point temp = *this;
   ++*this;
   return temp;
}

// Define prefix decrement operator.
Point& Point::operator--()
{
   _x--;
   _y--;
   return *this;
}

// Define postfix decrement operator.
Point Point::operator--(int)
{
   Point temp = *this;
   --*this;
   return temp;
}

int main()
{
}

Les mêmes opérateurs peuvent être définis dans l’étendue de fichier (globalement) à l’aide des prototypes de fonction suivants :

friend Point& operator++( Point& );      // Prefix increment
friend Point operator++( Point&, int );  // Postfix increment
friend Point& operator--( Point& );      // Prefix decrement
friend Point operator--( Point&, int );  // Postfix decrement

L’argument de type int qui désigne la forme postfix de l’opérateur incrément ou décrémentation n’est pas couramment utilisé pour passer des arguments. Il contient généralement la valeur 0. Toutefois, il peut être utilisé comme suit :

// increment_and_decrement2.cpp
class Int
{
public:
    Int operator++( int n ); // Postfix increment operator
private:
    int _i;
};

Int Int::operator++( int n )
{
    Int result = *this;
    if( n != 0 )    // Handle case where an argument is passed.
        _i += n;
    else
        _i++;       // Handle case where no argument is passed.
    return result;
}

int main()
{
   Int i;
   i.operator++( 25 ); // Increment by 25.
}

Il n’existe aucune syntaxe permettant d’utiliser les opérateurs d’incrémentation ou de décrémentation pour passer ces valeurs autres que l’appel explicite, comme indiqué dans le code précédent. Un moyen plus simple d’implémenter cette fonctionnalité consiste à surcharger l’opérateur addition/affectation (+=).

Voir aussi

Surcharge d'opérateur