Operador de subíndice de sobrecarga en C++

Este artículo demostrará cómo sobrecargar el operador de índice / subíndice en C++.

Operador de subíndice de sobrecarga usando la notación operator[] en C++

La sobrecarga de operadores es una característica poderosa del lenguaje C++. Le da al programador las facilidades para redefinir el significado de los operadores existentes para cualquier clase definida por el usuario. Esencialmente, los operadores sobrecargados son funciones y se definen como tales, excepto que tienen nombres especiales. Los nombres deben comenzar con el prefijo operador seguido del símbolo del operador que se está sobrecargando.

Generalmente, las funciones de sobrecarga del operador tienen el mismo número de parámetros que los operandos del operador dado. Entonces, nuestra sobrecarga de operador de subíndice aceptará dos parámetros. El siguiente código de ejemplo demuestra una implementación de la clase MyClass que tiene la función miembro operator[] que realiza una operación de acceso al elemento en la estructura interna del vector y devuelve la referencia al elemento. MyClass es básicamente la clase contenedora alrededor del contenedor std::vector y proporciona varias funciones miembro por motivos de demostración.

Observe que la función miembro operator[] tiene un parámetro como operador de subíndice habitual. Sin embargo, tenga en cuenta que cuando la función del operador se declara como una función miembro, tiene el primer parámetro vinculado al puntero implícito this. Por lo tanto, podemos tener un parámetro menos que los operandos para las sobrecargas de operadores declaradas como funciones miembro.

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

Producción :

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

Tenga en cuenta que algunos operadores deben estar sobrecargados como función miembro, y uno de ellos es un operador de subíndice. Se recomienda que la función operator[] tenga un significado similar al del operador integrado, que recupera el elemento por la posición dada. La sobrecarga de subíndices debe devolver una referencia que se utilizará en ambos lados de la tarea. También es importante definir dos versiones de la función operator[], una para objetos que no son const y la otra para objetos const, ya que no queremos que la referencia devuelta sea asignable cuando el objeto en sí es const calificado.