Operador de sobrecarga en C++ y desreferencia

Question

Estoy practicando sobrecarga de operadores en C++ en este momento y tengo un problema. Creé una clase String, solo tiene campos para una matriz de caracteres otra es longitud. que tiene una cadena "Alicia tiene un gato" y cuando llamo

cout<<moj[2]; 

me gustaría conseguir 'i', pero ahora que estoy recibiendo moj + 16u dirección del Ministerio de Justicia + 2 sizeof (String) Cuando Llamo a

cout<<(*moj)[2]; 

funciona como debería, pero me gustaría desreferenciarlo en la definición de operador sobrecargado. Intenté muchas cosas pero no puedo encontrar una solución. Por favor corrigeme.

char & operator[](int el) {return napis[el];} 
const char & operator[](int el) const {return napis[el];} 

Y todo el código, las cosas importantes están en la página. Está compilando y trabajando.

#include <iostream> 
    #include <cstdio> 
    #include <stdio.h> 
    #include <cstring> 
    using namespace std; 

class String{ 
public: 

//THIS IS UNIMPORTANT------------------------------------------------------------------------------ 
char* napis; 
int dlugosc; 
    String(char* napis){ 
    this->napis = new char[20]; 
    //this->napis = napis; 
    memcpy(this->napis,napis,12); 
    this->dlugosc = this->length(); 
} 

    String(const String& obiekt){ 
    int wrt = obiekt.dlugosc*sizeof(char); 
    //cout<<"before memcpy"<<endl; 
    this->napis = new char[wrt]; 
    memcpy(this->napis,obiekt.napis,wrt); 

    //cout<<"after memcpy"<<endl; 
    this->dlugosc = wrt/sizeof(char); 
    } 

    ~String(){ 
    delete[] this->napis; 
    } 

    int length(){ 
    int i = 0; 
    while(napis[i] != '\0'){ 
     i++; 
    } 
    return i; 
    } 
     void show(){ 
     cout<<napis<<" dlugosc = "<<dlugosc<<endl; 
} 


//THIS IS IMPORTANT 
    char & operator[](int el) {return napis[el];} 
    const char & operator[](int el) const {return napis[el];} 
}; 


    int main() 
    { 

    String* moj = new String("Alice has a cat"); 
    cout<<(*moj)[2]; // IT WORKS BUI 
// cout<<moj[2]; //I WOULD LIKE TO USE THIS ONE 


    return 0; 
    } 

Answer 1

String* moj = new String("Alice has a cat"); 
cout<<(*moj)[2]; // IT WORKS BUI 
// cout<<moj[2]; //I WOULD LIKE TO USE THIS ONE 

Eso no se puede hacer, el operador subíndice en este último caso se aplica a un puntero. Solo es posible sobrecargar a los operadores cuando al menos uno de los argumentos es del tipo definido por el usuario (o una referencia a él, pero no un puntero); en este caso particular, los argumentos son String* y 2, ambos tipos fundamentales.

Lo que puede hacer es colocar el puntero del todo, no veo por qué lo necesita:

String moj("Alice has a cat"); 
// cout<<(*moj)[2]; <-- now this doesn't work 
cout<<moj[2]; // <-- but this does 

Answer 2

String * significa un puntero a una String, si desea hacer cualquier cosa con la que sí String tiene que desreferenciarlo con *moj. Lo que puede hacer en su lugar es la siguiente:

String moj = String("Alice has a cat"); // note lack of * and new 
cout << moj[2]; 

También tenga en cuenta que cualquier cosa que se puede asignar con new es necesario tachar después:

String *x = new String("foo"); 

// code 

delete x;