Operador de sobrecarga de subscrição em C++

Este artigo demonstrará como sobrecarregar o operador subscrito / índice em C++.

Operador de Subscrito de Sobrecarga usando a notação operator[] em C++

A sobrecarga do operador é um recurso poderoso da linguagem C++. Dá ao programador as facilidades para redefinir o significado dos operadores existentes para quaisquer classes definidas pelo usuário. Essencialmente, os operadores sobrecarregados são funções e são definidos como tal, exceto pelo fato de terem nomes especiais. Os nomes devem começar com o prefixo operator seguido pelo símbolo do operador que está sendo sobrecarregado.

Geralmente, as funções de sobrecarga do operador têm o mesmo número de parâmetros que os operandos do operador fornecido. Portanto, nossa sobrecarga de operador subscrito aceitará dois parâmetros. O código de exemplo a seguir demonstra uma implementação de classe MyClass que tem a função de membro operator[] que conduz uma operação de acesso ao elemento na estrutura interna do vetor e retorna a referência ao elemento. MyClass é basicamente a classe wrapper em torno do contêiner std::vector e fornece várias funções-membro para fins de demonstração.

Observe que a função de membro operator[] tem um parâmetro como o operador subscrito usual. Lembre-se, porém, de que quando a função do operador é declarada como uma função-membro, ela tem o primeiro parâmetro vinculado ao ponteiro this implícito. Portanto, podemos ter um parâmetro a menos que os operandos para sobrecargas de operador declaradas como funções de membro.

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

Produção:

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

Observe que alguns operadores devem ser sobrecarregados como a função de membro e um deles é um operador subscrito. A função operator[] é recomendada para ter um significado semelhante ao do operador embutido, que recupera o elemento pela posição dada. A sobrecarga de subscrito deve retornar uma referência a ser usada em ambos os lados da atribuição. Também é importante definir duas versões da função operator[], uma para objetos não const e outra para objetos const, uma vez que não queremos que a referência retornada seja atribuível quando o próprio objeto é const qualificado.