C++ Operator Überladung Auflösung Ambiguität

Question

Ich versuche, eine antike C++ - Code-Basis von gcc 3.2 auf gcc 4.1 zu verschieben, da ich ein paar Probleme habe. Von all den Problemen bleibt mir Folgendes ahnungslos (ich denke ich habe zu viel Zeit mit Java verbracht oder ich habe die Grundlagen von C++ vergessen :-P).

Ich habe eine Template-Klasse

template < class T > class XVector <T> 
{ 
    ... 
    template < class T > T 
    XVector <T>::getIncrement() 
    { 
     ... 
    } 
    template < class T > int 
    XVector <T>::getValue (size_t index, T& value) 
    { 
     ... 
     //The problematic line 
     value = (T) (first_value + getIncrement()) 
        * (long) (index - first_index); 
     .... 
    } 
} 

Diese Klasse auf der STL std basiert :: vector. Ich habe eine zweite Klasse TypeValue und seine wie folgt definiert, die eine der int, long und ihre vorzeichenlosen Varianten float, double, std :: string enthalten können. Überlastet auch fast alle möglichen Betreiber.

class TypeValue 
{ 
    union 
    { 
     long* _int_value; 
     double* _real_value; 
     string* _text_value; 
    } _value; 

    TypeValue(); 
    explicit TypeValue(long _long); 
    explicit TypeValue(int _int); 
    explicit TypeValue(unsigned long _ulong); 
    ... 
    //similarly for all the remaining supported types. 
    TypeValue(const TypeValue&) //Copy constructor 

    virtual TypeValue& operator=(const TypeValue &rhs); 
    TypeValue& operator+ (TypeValue&)const; 
    TypeValue& operator* (TypeValue&)const; 
    ... 
    //For all the basic operators 

    operator long() const; 
    operator int() const; 
    operator unsigned long() const; 
    operator unsigned int() const; 
    ... 

} 

Und schließlich ich eine andere Klasse, nennen wir es die build_breaker, die ein Objekt als XVector <TypeValue> a_variable; schafft. Wenn ich das nun auf gcc 3.2 kompiliere, kompiliert das ohne Probleme. Aber wenn ich versuche, diese auf gcc kompilieren 4.1 bekomme ich Fehler mehrdeutig Überlastung für operator* in der Klasse XVector sagen, und die Kandidaten

 
operator*(long int, long int) 
operator*(int, long int) 
operator*(long unsigned int, long int) 
operator*(unsigned int, long int) 
operator*(double, long int) 
operator*(float, long int) 

wird, wenn der Compiler sagte, es hatte Probleme ein Spiel für T zu finden * lang, das hätte hat Sinn gemacht, aber warum versucht es, es in den nativen Typ zu schreiben und dann die arithmetische Operation durchzuführen? Bitte helfen Sie mir dabei.

Vielen Dank im Voraus.

Answer 1

Der zweite Operandentyp ist long [int]. Die erste ist TypeValue, ich erwarte, aber es gibt keinen Operator *, der diese beiden genauen Typen nimmt. Es gibt jedoch viele andere Typkombinationen für diesen Operator, die der Compiler durch eine implizite Konvertierung für den ersten Operanden auswählen kann. Die Sprache erlaubt dem Compiler dies zu tun, um zu versuchen, eine Übereinstimmung zu finden.

Aber welche der vielen Konvertierungen sollte es wählen? Der Compiler hat keine Möglichkeit zu wählen, ob int besser ist als long int. (Sie könnten argumentieren, dass, da der zweite Operand long int ist, sollte dies das bevorzugte Konvertierungsziel sein, aber das ist nicht die Art und Weise funktioniert.)

Also, ein Tipp: Erstens, nicht so viele implizite Konvertierungen liefern. Da die Klasse nur long, double und string enthalten kann, sind dies die einzigen drei Konvertierungen, die ich bereitstellen würde. Das allein wird wahrscheinlich Ihr Problem nicht lösen, aber es kann die Größe der Fehlerausgabe verringern und andere Dinge besser handhabbar machen.

Statt (index - first_index) der Umwandlung long zu geben, sollte deren Umwandlung T (das heißt, TypeValue) statt zu geben, denn das scheint der Betrieb zu sein, das Sie wirklich an erster Stelle ausführen wollten.

Answer 2

Wir müssten wissen, was T ist. Es sieht so aus, als ob Sie einen XVector mit einem Typ (wie unsigned char zum Beispiel), der in alle diese Typen umgewandelt werden kann, und der Compiler weiß es nicht welches man wählen sollte.

Answer 3

Ich würde alle Konvertierungs Betreiber benannten Funktionen ändern, so dass:

operator long() const; 

wird

long ToLong() const; 

Implizite conversiopns über Cast-Operatoren verursachen alle möglichen Probleme und meine eigenen Programmierstandards verbietet ihre benutzen.