Operatore di overloading in C++ e dereference

Question

Sto esercitando gli operatori di overloading in C++ in questo momento e ho un problema. Ho creato una classe String, ha solo per i campi uno è l'array di caratteri altro è la lunghezza. Ho uno String "Alice ha un gatto" e quando chiamo

cout<<moj[2]; 

vorrei ottenere 'i', ma ora sto ottenendo moj + 16u indirizzo di Moj + 2 sizeof (String) Quando Chiamo

cout<<(*moj)[2]; 

funziona come dovrebbe, ma vorrei dereferenziarlo nella definizione dell'operatore sovraccarico. Ho provato molte cose ma non riesco a trovare una soluzione. Per favore correggimi.

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

E l'intero codice, le cose importanti sono in fondo alla pagina. Sta compilando e lavorando.

#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 

Ciò non può essere fatto, l'operatore pedice in quest'ultimo caso viene applicato a un puntatore. È possibile sovraccaricare gli operatori solo quando almeno uno degli argomenti è di tipo definito dall'utente (o un riferimento ad esso, ma non un puntatore); in questo caso gli argomenti sono String* e 2, entrambi i tipi fondamentali.

Che cosa si può fare è rilasciare il puntatore del tutto, non vedo il motivo per cui avete bisogno:

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 puntatore ad una String, se si vuole fare qualsiasi cosa con il String stesso ti devi dereferenziarlo con *moj. Che cosa si può fare, invece è questa:

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

Si noti inoltre che qualsiasi cosa si alloca con new necessario cancellare dopo:

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

// code 

delete x;