opérateur Surcharge en C++ comme int + obj

Question

je suit classe: -

class myclass 
{ 
    size_t st; 

    myclass(size_t pst) 
    { 
     st=pst; 
    } 

    operator int() 
    { 
     return (int)st; 
    } 

    int operator+(int intojb) 
    { 
     return int(st) + intobj; 
    } 

}; 

cela fonctionne bien aussi longtemps que je l'utilise comme ceci: -

char* src="This is test string"; 
int i= myclass(strlen(src)) + 100; 

mais je suis incapable de le faire ceci: -

int i= 100+ myclass(strlen(src)); 

Une idée, comment puis-je réaliser ceci?

Answer 1

Mettre en oeuvre l'opérateur surcharge en dehors de la classe:

class Num 
{ 
public: 
    Num(int i) 
    { 
     this->i = i; 
    } 

    int i; 
}; 

int operator+(int i, const Num& n) 
{ 
    return i + n.i; 
} 

Answer 2

Vous avez besoin d'un opérateur de fonction globale + (int, maclasse) pour le faire:

int operator+(int intobj, myclass myobj) 
{ return intobj + int(myobj); } 

Answer 3

Vous devez mettre en œuvre l'opérateur en tant que la fonction non-membre pour autoriser un int primitif sur le côté gauche.

int operator+(int lhs, const myclass& rhs) { 
    return lhs + (int)rhs; 
} 

Answer 4

Les autres réponses ici va résoudre le problème, mais ce qui suit est le modèle que je l'utilise quand je fais ceci:

class Num 
{ 
public: 
    Num(int i)  // Not explicit, allows implicit conversion to Num 
    : i_ (i) 
    { 
    } 

    Num (Num const & rhs) 
    : i_ (rhs.i_) 
    { 
    } 

    Num & operator+= (Num const & rhs) // Implement += 
    { 
    i_ += rhs.i_; 
    return *this; 
    } 

private: 
    int i_; 
}; 

// 
// Because of Num(int), any number on the LHS or RHS will implicitly 
// convert to Num - so no need to have lots of overloads 
Num operator+(Num const & lhs, Num const & rhs) 
{ 
    // 
    // Implement '+' using '+=' 
    Num tmp (lhs); 
    tmp+=rhs; 
    return tmp; 
} 

L'un des principaux avantages de cette approche est que vos fonctions peut être implémenté en termes de réduction de la quantité de code global dont vous avez besoin.

MISE À JOUR:

Pour garder les problèmes de performances à distance, je définirais probablement l'opérateur non membre + comme quelque chose comme la fonction en ligne:

inline Num operator+(Num lhs, Num const & rhs) 
{ 
    lhs+=rhs; 
    return lhs; 
} 

Les opérations membres sont également en ligne (comme ils 're déclaré dans le corps de la classe) et donc dans tout le code devrait être très proche du coût de l'ajout de deux objets int premières. Enfin, comme le souligne jalf, les conséquences de l'autorisation de conversions implicites en général doivent être prises en compte. L'exemple ci-dessus suppose qu'il est judicieux de convertir un type intégral en un 'Num'.