Surcharger l'opérateur d'indice en C++

Cet article montrera comment surcharger l’opérateur indice/index en C++.

Overload Subscript Operator Utilisation de la notation operator[] en C++

La surcharge d’opérateurs est une fonctionnalité puissante du langage C++. Il donne au programmeur la possibilité de redéfinir la signification des opérateurs existants pour toutes les classes définies par l’utilisateur. Essentiellement, les opérateurs surchargés sont des fonctions et sont définis comme tels, sauf qu’ils ont des noms spéciaux. Les noms doivent commencer par le préfixe operator suivi du symbole de l’opérateur surchargé.

Généralement, les fonctions de surcharge d’opérateur ont le même nombre de paramètres que les opérandes de l’opérateur donné. Ainsi, notre surcharge d’opérateur d’indice acceptera deux paramètres. L’exemple de code suivant montre une implémentation de classe MyClass qui a la fonction membre operator[] qui effectue une opération d’accès à l’élément sur la structure interne vector et renvoie la référence à l’élément. MyClass est essentiellement la classe wrapper autour du conteneur std::vector et fournit plusieurs fonctions membres à des fins de démonstration.

Notez que la fonction membre operator[] a un paramètre comme opérateur d’indice habituel. Attention cependant, lorsque la fonction opérateur est déclarée en tant que fonction membre, elle a le premier paramètre lié au pointeur this implicite. Ainsi, nous pouvons avoir un paramètre de moins que les opérandes pour les surcharges d’opérateur déclarées comme fonctions membres.

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

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

template <typename T>
class MyClass {
 public:
  MyClass() = default;
  explicit MyClass(const T &data) { vec.push_back(data); };
  MyClass(std::initializer_list<T> list) {
    vec.insert(vec.end(), list.begin(), list.end());
  };

  void push_back(const T &data) { vec.push_back(data); };

  void pop_back() { vec.pop_back(); };

  size_t size() { return vec.size(); };

  T &operator[](size_t pos) { return vec.at(pos); };

  const T &operator[](size_t pos) const { return vec.at(pos); };

 private:
  vector<T> vec;
  string name;
};

int main() {
  MyClass<string> m1 = {"top", "mop", "gop", "sop"};

  for (size_t i = 0; i < m1.size(); ++i) {
    cout << m1[i] << endl;
  }

  cout << "/ ------------------- /" << endl;

  m1.pop_back();
  m1.pop_back();

  for (size_t i = 0; i < m1.size(); ++i) {
    cout << m1[i] << endl;
  }

  return EXIT_SUCCESS;
}

Production:

top
mop
gop
sop
/ ------------------- /
top
mop

Notez que certains opérateurs doivent être surchargés en tant que fonction membre, et l’un d’eux est un opérateur d’indice. La fonction operator[] est recommandée pour avoir une signification similaire à celle de l’opérateur intégré, qui récupère l’élément par la position donnée. La surcharge d’indice doit renvoyer une référence à utiliser des deux côtés de l’affectation. Il est également important de définir deux versions de la fonction operator[], une pour les objets non const et l’autre pour les objets const, car nous ne voulons pas que la référence renvoyée soit assignable lorsque l’objet lui-même est qualifié const.