定义模板运算符重载时出错

Question

Here's an attempted templated overload of operator+. This fails to compile with both gcc 4.8 and icc 14.0.3.

template <typename T>
class B
{
public:
  B operator+(const B& rhs)
  {
    return *this;
  }
};

template <typename T>
class A
{
public:
  operator B<T>() const{return B<T>();}
};

// template<typename T>                                                                                                                                                        
// B<T> operator+(A<T> const& t, A<T> const& u)                                                                                                                                
// {                                                                                                                                                                           
//   return (B<T>)t + (B<T>)u;                                                                                                                                                 
// }                                                                                                                                                                           

template<typename T, typename U>
B<U> operator+(A<T> const& t, A<T> const& u)
{
  return (B<U>)t + (B<U>)u;
}

int main()
{
  A<double> a,b;
  B<double> c = a+b;
  return 0;
}

However, the commented overload works fine. What is the difference? Why doesn't the template with two parameters match?

g++48 -std=c++11 temp2.cpp
temp2.cpp: In function ‘int main()’:
temp2.cpp:33:18: error: no match for ‘operator+’ (operand types are ‘A<double>’ and ‘A<double>’)
   B<double> c = a+b;
                  ^
temp2.cpp:33:18: note: candidate is:
temp2.cpp:25:6: note: template<class T, class U> B<U> operator+(const A<T>&, const A<T>&)
 B<U> operator+(A<T> const& t, A<T> const& u)
      ^
temp2.cpp:25:6: note:   template argument deduction/substitution failed:
temp2.cpp:33:19: note:   couldn't deduce template parameter ‘U’
   B<double> c = a+b;

Answer 1

The compiler is telling you why it failed:

temp2.cpp:25:6: note: template argument deduction/substitution failed:
temp2.cpp:33:19: note: couldn't deduce template parameter 'U'

The template parameter U only appears in the return type of the function template, and so it cannot be deduced. Your code will compile if you explicitly list the template arguments

B<double> c = operator+<double, double>(a, b);

---

And if you swap the order of the template parameters so that U appears before T , you can still allow T to be deduced.

template<typename U, typename T>
B<U> operator+(A<T> const& t, A<T> const& u)
{
  return (B<U>)t + (B<U>)u;
}

B<double> c = operator+<double>(a, b);

---

The commented out operator+ implementation works because the return type is also using the same type argument T , thus allowing it to be deduced from the function template arguments.

Answer 2

In

B<double> c = a+b;

the type template parameter U in

B<U> operator+(A<T> const& t, A<T> const& u)

cannot be deduced. U will not be deduced as double simply because the result of the call is being assigned to B<double> . You would have to explicitly specify U as double , for example by the following,

B<double> c = operator+<double, double>(a, b);

Now obviously this is likely not a desirable situation. So what can you do? Well, it's hard to say because you haven't specified what A and B are to be used for. But, as you've already discovered, your code compiles with the commented-out operator,

template<typename T>
B<T> operator+(A<T> const& t, A<T> const& u)
{
    return (B<T>)t + (B<T>)u;
}

For some reason you seem to want it to be possible to use the result to initialize a B<U> where U might not be the same as T , so perhaps the right solution is to make it possible to construct B<U> from B<T> :

template <typename T>
class B
{
public:
  template <typename U>
  B(const B<U>& rhs) {
    // ...
  }
  // ...
};

(You likely also want to write a similar assignment operator.)

Answer 3

The error message from the compiler is clear. It is not able to deduce parameter U to instantiate the operator+ function.

You can be explicit by using:

B<double> c = operator+<double, double>(a,b);

Answer 4

Return types are not deduced.

You can fake it with expression templates.

template<template<class>class Op, class Rhs, class Lhs>
struct deferred{
    Lhs lhs; Rhs rhs;
    template<typename Result>
    operator Result() const { return Op<Result>{}( std::forward<Lhs>(lhs), std::forward<Rhs>(rhs) ); }
};

template<class R> sum;
template<class U> sum<B<U>>{
  template<class Lhs, class Rhs>
  B<U> operator()( A<Lhs> const& lhs, A<Rhs> const& rhs )const{
    return B<Lhs>(lhs)+B<Rhs>(rhs);
  }
};
template<class T>
deferred<sum, A<T>const&, A<T>const&> operator+( A<T>const& a, A<T>const& b){
  return {a,b};
}

which should give you the idea.