remplacer la surcharge de l'opérateur en C++?

Question

gars helo

j'ai appel de classe complexe

je l'ai fait la surcharge d'opérateur comme tel

Complex c = a + b; // where a and b are object of Complex class 

qui est essentiellement opérateur + (Complexe & que);

mais je ne sais pas comment dire par exemple

double c = a + 10; //where a is object of Complex class but 10 is integer/double 

Je ne définissaient transtypage pour être le double obtenir mon IDE dit qu'il ya trop de opérandes + et il se plaint d'une certaine manière pour ne pas être en mesure de " comprendre » le +

il doit être dans ce format si double c = a + 10;

grâce

message d'erreur est

Error: more than one operator "+" matches these operands: 
error C2666: 'Rational::operator +' : 3 overloads have similar conversions 

1> could be 'const Complex Complex::operator +(const Complex &)' 1> 
or 'double operator +(const Complex &,double)' 

le compilateur ne peut pas choisir en fonction de la signature? et oui je ne définissaient en dehors de la classe parce que j'avais celui défini dans la classe grâce

Answer 1

double operator+(const Complex &c, int x) 
{ 
    //.... 
} 

Answer 2

surcharge operator+ pour un double opérande:

double Complex::operator+(double rhs) 

Answer 3

Que diriez-vous de mettre dans un constructeur de la forme:

Complex(float _real) : m_Real(_real), m_Imaginary(0){} 

de sorte que toute valeur qui peut être converti en un float peut être ingérée en tant que Complex. Ensuite, vous n'avez pas besoin de faire un opérateur surchargé pour toutes sortes de types. Celui que vous avez écrit pour Complex suffira.

Answer 4

Si vous envisagez de le faire, vous pouvez procéder comme suit. Tout d'abord, nous définissons les éléments suivants (en dehors de la classe afin que la conversion implicite pour le premier et le second opérande est autorisé), ne définit aucun autre opérateur +, comme opérateur + (Complexe, double):

Complex operator+(const Complex& a, const Complex& b) { 
    // .. 
} 

Au en même temps de définir un constructeur implicite:

Complex(double a) : real(a), imag(0) {} 

Et puis définissez l'opérateur de conversion (comme Wheaties ont souligné, cela peut être considéré comme une mauvaise pratique de programmation, que je suis d'accord, donc si la conversion finale du double n'est pas nécessaire, omettre ceci):

operator double() const { return real; } 

Cela soutiendra automatiquement double c = a_complex + 10; et double c = 10 + a_complex;, le nombre 10 sera implicitement converti en un Complex utilisant le constructeur implicite et l'arithmétique résoudra à operator+(const Complex&, const Complex&);, le résultat sera converti en doubler automatiquement.

P.S. Vous pouvez également définir Complex& operator+=(const Complex& o) { /* .. */ } dans la classe et l'utiliser pour implémenter operator+ ci-dessus.

Answer 5

La raison pour laquelle vous obtenez l'erreur de surcharge ambiguë est que vous avez operator+ variantes qui peuvent ajouter deux Complex ou un Complex et un double, mais vous essayez d'ajouter un Complex et un int. Le compilateur ne peut pas décider s'il est préférable de convertir le int en Complex pour utiliser le premier ou le double et utiliser le second.

Pour éviter cela, vous devez soit définir une surcharge operator+ pour tous les types possibles que vous pouvez ajouter à un Complex (int, float, long, non signé ...) OU surchargez pas operator+ en premier lieu - juste définir un SIMPLE operator+ qui ajoute deux Complex et laisser les conversions de type traiter tous les autres cas.