C ++运算符重载分辨率含糊不清

Question

Am trying to move an antique C++ code base from gcc 3.2 to gcc 4.1, as I have run into a few issues. Of all the issues, the following is left me clueless (I guess I spent too much time with Java or I might have forgotten the basics of C++ :-P ).

I have a template class

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);
      ....
   }
}

This class is based on the STL std::vector. I have a second class TypeValue and its defined as below which can hold one of int, long and their unsigned variants, float, double, std::string. Also overloads almost all possible operators.

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;
    ...

}

And finally I have another class, lets call it the build_breaker, which creates an object as XVector < TypeValue > a_variable; . Now when I compile this on gcc 3.2 this compiles without any problems. But when I try compiling this on gcc 4.1 I get errors saying ambigous overload for operator* in the class XVector and the candidates being

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)

If the compiler said it had problems finding a match for T * long, that would have made sense, but, why is it trying to typecast it to native type and then perform the arithmetic operation? Please help me on this.

Thanks in advance.

Answer 1

The second operand type is long [int] . The first is TypeValue , I expect, but there is no operator * that takes those two exact types. There are lots of other type combinations for that operator, though, which the compiler can select by doing an implicit conversion on the first operand. The language allows the compiler to do that to try to find a match.

But which of the many conversions should it choose? The compiler has no way to choose whether int is better than long int . (You might argue that since the second operand is long int , that should be the preferred conversion target, but that's not the way things work.)

So, some advice: First, don't supply so many implicit conversions. Since the class can only hold long , double , and string , those are the only three conversions I'd supply. That alone probably won't solve your problem, but it may reduce the size of the error output and make other things more manageable.

Instead of converting (index - first_index) to type long , consider converting it to type T (ie, TypeValue ) instead, since that seems to be the operation you really wanted to perform in the first place.

Answer 2

I would change all the conversion operators to named functions so that:

operator long() const;

becomes

long ToLong() const;

Implicit conversiopns via cast operators cause all sorts of problems, and my own programming standards bans their use.

Answer 3

我们需要知道什么是T。看起来您正在使用某种类型（例如，无符号字符）实例化一个XVector，该类型可以转换为您看到的所有这些类型，并且编译器不知道该选择哪种类型。 。