Che cosa significa "operatore = deve essere un membro non statico"?

Question

Sono nel processo di creazione di un elenco doppio-linked, e hanno sovraccaricato l'operatore = per fare in lista pari un'altra:

template<class T> 
void operator=(const list<T>& lst) 
{ 
    clear(); 
    copy(lst); 
    return; 
} 

ma ottengo questo errore quando provo a compilare:

container_def.h(74) : error C2801: 'operator =' must be a non-static member 

Inoltre, se è utile, la riga 74 è l'ultima riga della definizione, con "}".

Answer 1

Esattamente quello che dice: i sovraccarichi dell'operatore con 1 parametro devono essere funzioni membro. (Dichiarata all'interno della classe)

template<class T> 
void list<T>::operator=(const list<T>& rhs) 
{ 
    ... 
} 

Inoltre, è probabilmente una buona idea per restituire la LHS from = modo è possibile concatenare esso (come a = b = c) - in modo da rendere più list<T>& list<T>::operator=....

Answer 2

Se si esegue l'overload di un operatore come una funzione membro, si dovrebbe utilizzare questo modello:

class A { 
    A& operator=(const A& other) { 
    if (this != &other) { 
     ... 
    } 
    return *this; 
    } 
} 

Tre cose da notare:

1. Verificare l'autoassegnazione con l'operatore di assegnazione (come sopra);
2. L'argomento deve essere un riferimento const; e
3. Restituisce il risultato dell'operazione come riferimento non const in cui si restituisce * questo per consentire il concatenamento degli operatori.

È inoltre possibile sovraccaricare un operatore esterno alla classe. Questo non è rilevante per questo esempio perché non è possibile farlo con l'operatore di assegnazione, ma vale la pena notare perché in molti casi è superiore alle funzioni dei membri. La forma tipica è:

class A { 
    friend const A& operator+(const A& a, const A& b); 
    ... 
} 
const A& operator+(const A& a, const A& b) { 
    A& ret = ... 
    return ret; 
} 

Questo restituisce un riferimento const quindi non è possibile fare questo:

(a + b) = c 

Answer 3

Metti che operatore all'interno della vostra definizione di classe. Deve essere un membro perché operator= è speciale e non si otterrebbe qualcosa scrivendolo comunque come non membro. Un operatore non membro ha due importanti vantaggi principali:

• conversioni implicite del diritto e il lato sinistro dell'operatore invocazione
• Non c'è bisogno di conoscere interni della classe. La funzione può essere realizzata come non-membro non-amico.

Per operator=, entrambi non sono utilizzabili. Assegnare a un risultato temporaneo di una conversione non ha senso, e nella maggior parte dei casi sarà necessario l'accesso a internals operator=. Inoltre, uno speciale operator= viene fornito automaticamente da C++ se non ne viene fornito uno (il cosiddetto operatore di copia-assegnazione). Rendere possibile sovraccaricare operator= come non membro avrebbe introdotto una complessità aggiuntiva per apparentemente nessun guadagno pratico, e quindi non è permesso.

Quindi modificare il codice in modo che assomiglia a questo (. Questo presuppone l'operator= è non un operatore di copia-assegnazione, ma assegnando da una list<T> a qualcos'altro Questo non è chiaro dalla tua domanda):

class MyClass { 
... 
    template<class T> 
    MyClass& operator=(const list<T>& lst) 
    { 
     clear(); 
     copy(lst); 
     return *this; 
    } 
... 
}; 

È piuttosto normale che uno operator= restituisca nuovamente un riferimento a se stesso. Ti raccomando di aderire a questa pratica. Sembrerà familiare ai programmatori e potrebbe causare sorprese se restituisse lo void all'improvviso.

Answer 4

Da C++ standard, "Operatori binari":

"Un operatore binario sono attuati da una funzione membro non statica con un parametro o da una funzione non membro con due parametri"

Vuole che tu lo definisca in una classe, come membro, o lo renda un metodo statico (nel qual caso dovrebbe prendere due parametri (sia per lval che per rval)