Opérateurs en C++

1. Opérateurs communs fournis dans le langage C++
2. Opérations surchargées en C++

Cet article présente plusieurs méthodes sur l’utilisation des opérateurs en C++.

Opérateurs communs fournis dans le langage C++

Les opérateurs sont la partie essentielle des expressions en programmation C++. Ils fournissent différentes opérations menées sur les opérandes fournis, et les résultats évalués sont généralement utilisés par le programmeur selon les besoins. Nous pouvons diviser grossièrement les opérandes en deux types : les opérateurs communs et spéciaux. Les opérateurs communs sont des opérations presque universellement implémentées dans la plupart des langages de programmation, et ceux-ci incluent l’arithmétique, la logique, la comparaison, l’affectation, les opérateurs d’accès aux membres et plusieurs autres.

Semblable aux règles de l’algèbre, il existe des caractéristiques de priorité et d’associativité lorsque plusieurs opérateurs forment l’expression. Nous allons résumer certaines de ces règles dans cet article, mais la description complète doit être renvoyée à la documentation du langage et à l’opérateur tableau de priorité. Notez que les règles de priorité et d’associativité pour les opérations arithmétiques de base sont similaires aux règles mathématiques courantes. Ainsi, les expressions de l’exemple suivant renvoient les entiers 20 et 10 au lieu de 60 et 30.

#include <iostream>

using std::cout;
using std::endl;

int main() {
  cout << 10 + 2 * 5 << endl;
  cout << 40 - 20 - 10 << endl;

  return EXIT_SUCCESS;
}

Production:

20 10

Le programmeur peut utiliser des parenthèses pour outrepasser les règles générales de priorité et d’associativité, de la même manière qu’en algèbre. Chaque expression composée entre parenthèses sera traitée comme une unité évaluée séparément. L’une des erreurs courantes lors de l’utilisation de l’arithmétique du pointeur est de manquer les parenthèses.

Si nous accédons à l’élément du tableau en utilisant l’arithmétique du pointeur plus l’opération de déréférencement, nous devons mettre l’arithmétique entre parenthèses. Sinon, la valeur pointée par le pointeur donné serait incrémentée de l’opérande numérique et non du pointeur lui-même car l’opérateur de déréférencement a une priorité plus élevée que l’addition.

#include <iostream>

using std::cout;
using std::endl;

int main() {
  int vec[] = {10, 22, 63, 14};
  cout << *vec + 2 << endl;
  cout << *(vec + 2) << endl;

  return EXIT_SUCCESS;
}

Production:

12 63

Opérations surchargées en C++

L’une des fonctionnalités les plus puissantes que l’on puisse rencontrer dans le langage C++ est qu’il permet au programmeur de définir comment les opérateurs doivent se comporter lorsqu’ils sont appelés sur des objets définis par l’utilisateur comme des classes. Étant donné que cette fonctionnalité donne des opérations alternatives à l’opérateur donné, elle est appelée opérateurs surchargés. Cependant, notez que le nombre d’opérandes et la priorité ne peuvent pas être modifiés en implémentant un opérateur surchargé.

L’extrait de code suivant déclare une classe Person qui contient deux membres de données de chaîne et surcharge l’opérateur + pour ce type. Les opérateurs surchargés sont implémentés de la même manière que les autres fonctions de classe avec des noms spéciaux, commençant par le mot-clé operator suivi du symbole de l’opérateur lui-même. Ces fonctions peuvent avoir un type de retour et une liste de paramètres. Gardez à l’esprit que l’une des restrictions de la surcharge d’opérateurs est que le programmeur ne peut pas créer de nouveaux opérateurs comme $> ou !!.

#include <iostream>
#include <string>
#include <utility>
#include <vector>

using std::cout;
using std::endl;
using std::string;
using std::vector;

class Person {
 public:
  Person(string s1, string s2) : name(std::move(s1)), surname(std::move(s2)) {}

  Person operator+(const Person &p) {
    Person ret(name + p.name, surname + p.surname);
    return ret;
  }

  void printPerson() { cout << name << " " << surname << endl; }

 private:
  string name;
  string surname;
};

int main() {
  Person P1("Buddy", "Rich");
  Person P2("Lady", "Bee");
  P1 = P1 + P2;

  P1.printPerson();

  exit(EXIT_SUCCESS);
}

Production:

BuddyLady RichBee