Opérateur surchargé surchargé =?

Question

Que puis-je faire lorsque j'ai besoin d'un travail différent, en fonction du type rval et lval? La définition de plusieurs surcharges apparaît avec l'erreur 'opérateur = est ambigu'.

Toutes les idées, ou conseils (liens vers des tutoriels), sont très appréciés, car je viens d'apprendre aujourd'hui sur la surcharge de l'opérateur.

Merci d'avance!

EDIT:

Oui, j'utiliser C++ 0x depuis que je l'ai disponible, juste que je ne vois pas comment serait-il impact sur le code?

Ce sont deux cas dans lesquels je l'utilise atm, si je l'obtiens bien lval est différent, donc ils sont reconnaissables. Le but est la conversion au type approprié.

int wrapint::operator=(int) 
{ 
    return m_iCurrentNumber; 
} 

void wrapint::operator=(const int& rhs) 
{ 
    m_iCurrentNumber = rhs; 
} 

Answer 1

Pour situation wrapint = wrapint de:

wrapint& wrapint::operator=(const wrapint& rhs) 
{ 
    // test for equality of objects by equality of address in memory 
    // other options should be considered depending on specific requirements 
    if (this == &rhs) return *this; 

    m_iCurrentNumber = rhs.m_iCurrentNumber; 

    return *this; 
} 

je dois dire que ce qui précède est une signature correcte pour un opérateur d'affectation. Je pense que les signatures que vous avez fournies sont fausses, ou du moins je n'ai jamais vu une telle chose dans mon expérience avec C++.

Si vous voulez convertir d'un int à un wrapint et dans l'autre sens, vous devez fournir les informations suivantes:

1) de int à wrapint - un constructeur approprié qui permettra la conversion implicite de int; comme un côté note vous devriez vraiment vous assurer que le comportement est prévu et dans la portée du problème lorsque vous travaillez avec ces conversions implicites (jetez un oeil à mot-clé explicite de C++ pour plus « l'illumination »)

2) de wrapint int - un opérateur coulé approprié

Voici un exemple:

#include <iostream> 

class wrapint 
{ 
public: 
    wrapint() : m_iCurrentNumber(0) 
    { 

    } 

    // allow implicit conversion from int 
    // beware of this kind of conversions in most situations 
    wrapint(int theInt) : m_iCurrentNumber(theInt) 
    { 

    } 

    wrapint(const wrapint& rhs) 
    { 
    if (this != &rhs) 
     this->m_iCurrentNumber = rhs.m_iCurrentNumber; 
    } 

    wrapint& operator=(const wrapint& rhs); 

    operator int() 
    { 
     return m_iCurrentNumber; 
    } 

private: 
    int m_iCurrentNumber; 
}; 

wrapint& wrapint::operator=(const wrapint& rhs) 
{ 
    // test for equality of objects by equality of address in memory 
    // other options should be considered depending on specific requirements 
    if (this == &rhs) return *this; 

    m_iCurrentNumber = rhs.m_iCurrentNumber; 
    return *this; 
} 

using namespace std; 

int main() 
{ 
    // this will be initialized to 0 
    wrapint theOne; 
    // this will be 15 
    wrapint theOtherOne = 15; 

    cout << "The one: " << theOne << "\n"; 
    cout << "The other one: " << theOtherOne << "\n"; 

    theOne = theOtherOne; 

    int foobar = theOne; 
    // all should be 15 
    cout << "The one: " << theOne << "\n"; 
    cout << "The other one: " << theOtherOne << "\n"; 
    cout << "The foobar: " << foobar << "\n"; 
    return 0; 
} 

Answer 2

operator= est censé modifier la valeur à la main gauche et la valeur à la main gauche doit être du type de classe. La valeur renvoyée (normalement *this) est généralement ignorée, sauf lorsque vous attribuez des affectations de chaîne/autres appels de fonction (par exemple a = b = c; où le résultat de b = c est affecté à a).

Si vous voulez être en mesure d'attribuer un wrapint à un intégré int, cela peut être réalisé en définissant un opérateur de cast pour wrapint

wrapint::operator int() const { return m_iCurrentNumber; } 

maintenant wrapint sera implicitement convertie en un entier, lorsque vous essayez d'en affecter un à un int.

int a; 
wrapint w; 
a = w; //== a = w.operator int()