Tiefgestellter Operator in C++ überladen

In diesem Artikel wird veranschaulicht, wie der Index-/Indexoperator in C++ überladen wird.

Tiefgestellten Operator mit der Notation operator[] in C++ überladen

Das Überladen von Operatoren ist eine leistungsstarke Funktion der Sprache C++. Es gibt dem Programmierer die Möglichkeit, die Bedeutung bestehender Operatoren für beliebige benutzerdefinierte Klassen neu zu definieren. Im Wesentlichen sind überladene Operatoren Funktionen und werden als solche definiert, außer dass sie spezielle Namen haben. Die Namen müssen mit dem Präfix operator beginnen, gefolgt von dem überladenen Operatorsymbol.

Im Allgemeinen haben Operatorüberladungsfunktionen dieselbe Anzahl von Parametern wie die Operanden des angegebenen Operators. Daher akzeptiert unsere Überladung des tiefgestellten Operators zwei Parameter. Der folgende Beispielcode demonstriert eine Implementierung der Klasse MyClass mit der Memberfunktion operator[], die eine Elementzugriffsoperation auf die interne Vektor-Struktur durchführt und die Referenz auf das Element zurückgibt. MyClass ist im Grunde die Wrapper-Klasse um den std::vector-Container und stellt zu Demonstrationszwecken mehrere Member-Funktionen bereit.

Beachten Sie, dass die Memberfunktion operator[] einen Parameter als den üblichen Indexoperator hat. Beachten Sie jedoch, dass, wenn die Operatorfunktion als Memberfunktion deklariert ist, der erste Parameter an den impliziten this-Zeiger gebunden ist. Somit können wir einen Parameter weniger haben als die Operanden für Operatorüberladungen, die als Memberfunktionen deklariert sind.

#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;
}

Ausgabe:

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

Beachten Sie, dass einige Operatoren als Memberfunktion überladen werden müssen und einer davon ein tiefgestellter Operator ist. Die Funktion operator[] sollte eine ähnliche Bedeutung haben wie der eingebaute Operator, der das Element an der angegebenen Position abruft. Die tiefgestellte Überladung sollte einen Verweis zurückgeben, der auf beiden Seiten der Zuweisung verwendet werden soll. Es ist auch wichtig, zwei Versionen der Funktion operator[] zu definieren, eine für Nicht-const-Objekte und die andere für const-Objekte, da wir nicht möchten, dass die zurückgegebene Referenz zuweisbar ist, wenn das Objekt selbst const qualifiziert.