C++: Operatore di overloading =

Question

Okay, quindi ho una classe che ha una "digitazione debole" I.E. è in grado di memorizzare molti tipi differenti definiti come:

#include <string> 

class myObject{ 
    public: 
     bool isString; 
     std::string strVal; 

     bool isNumber; 
     double numVal; 

     bool isBoolean; 
     bool boolVal; 

     double operator= (const myObject &); 
}; 

vorrei sovraccaricare l'operatore di assegnazione in questo modo:

double myObject::operator= (const myObject &right){ 
    if(right.isNumber){ 
     return right.numVal; 
    }else{ 
     // Arbitrary Throw. 
     throw 5; 
    } 
} 

In modo che io possa fare questo:

int main(){ 
    myObject obj; 
    obj.isNumber = true; 
    obj.numVal = 17.5; 
    //This is what I would like to do 
    double number = obj; 
} 

Ma quando Lo faccio, ottengo:

error: cannot convert ‘myObject’ to ‘double’ in initialization 

Al compito.

Ho anche provato:

int main(){ 
    myObject obj; 
    obj.isNumber = true; 
    obj.numVal = 17.5; 
    //This is what I would like to do 
    double number; 
    number = obj; 
} 

Al che ottengo:

error: cannot convert ‘myObject’ to ‘double’ in assignment 

C'è qualcosa che mi manca? o semplicemente non è possibile fare una conversione del genere sovraccaricando operator=.

Answer 1

Il sovraccarico operator= modifica il comportamento durante l'assegnazione di oggetti a del tipo di classe.

Se si desidera fornire la conversione implicita ad altri tipi, è necessario fornire un operatore di conversione, ad es.

operator double() const 
{ 
    if (!isNumber) 
     throw something(); 
    return numVal; 
} 

Answer 2

per quella di lavorare, è necessario implementare un operatore di conversione dal tuo oggetto al qualcosa che può essere convertito in un letto

Answer 3

cosa si vuole veramente sono operatori di conversione.

operator double() const { return numVal; } 
operator int() const { ... 

Detto questo, si sarebbe probabilmente piace boost::variant.

Answer 4

Per rendere una classe assegnabile a un doppio, l'operatore = deve essere definito in modo diverso.

double operator=(myclass&) è errato.

Che cosa potrebbe funzionare, è un operatore amico = al di fuori della classe, che accetta doppio e myclass &.

Answer 5

Il valore di ritorno di operator=() non può essere utilizzato come si è tentato di dimostrare. Se si pensa all'operatore sovraccarico come una funzione a sé stante, può avere più senso.

Ad esempio:

int main() { 
    myObject obj, obj2; 
    obj.isNumber = true; 
    obj.numVal = 17.5; 
    obj2.operator=(obj); // equivalent to obj2 = obj 
} 

Il motivo number = obj; non funziona è perché avete definito myObject::operator=(), mentre number sarebbe utilizzando double::operator=() (ok, tecnicamente non c'è doppia :: operator =() poiché è un tipo fondamentale e non una classe ... lavora solo con me qui).

Una nota interessante è che questa funzione si comporta come qualsiasi altra funzione in quanto il valore di ritorno (return right.numval;) viene ignorato quando non viene utilizzato. Tuttavia, il valore di ritorno può essere ceduto o utilizzato come il valore di ritorno di ogni altra funzione, quindi se si voleva davvero si potrebbe fare qualcosa di simile:

int main() { 
    myObject obj, obj2; 
    obj.isNumber = true; 
    obj.numVal = 17.5; 
    double number; 
    // number = obj; still won't work. 
    number = obj2 = obj; // equivalent to number = obj2.operator=(obj) 
} 

Questo è solo così utile. Come altri hanno già accennato, si vuole veramente esaminare gli operatori di conversione quando si tenta di assegnare gli oggetti myObject ai tipi fondamentali.