模板类运算符+重载返回类型

Question

I am trying to built a templated num class. This class needs to have a public attribute, val , with type T , which is the only templated parameter. Furthermore if one provides a value the attribute ( val ) should be initialized with this value. To do so I made the following code:

#include <iostream>

template<class T>
class Num {
public: 
    T val;

    Num():val(0) { std::cout<<"default constr used"<<std::endl; }
    Num(T value):val(value) {std::cout<<"constr (T value) used"<<std::endl; }
    ~Num() { std::cout<<"destructor used"<<std::endl; }

    template<typename U>
    Num operator+(const Num<U>& other) {
        return val+other.value;
    }
};

Furthermore I created the main() function to test the program, which looks like this:

int main() {
    std::cout << Num<int>(1) + Num<double>(2.0);
    return 0;
}

However the result of the program is now 3 . Whereas I expected it to be 3.0 (of type double ).

Answer 1

For that you will need to change the return type.

In your code:

// vvv---- Means Num<T>
   Num operator+(const Num<U>& other) {
       return val + other.val;
   }

Indeed, inside a class template, you can type the name of the class without template arguments and it's gonna be somewhat equivalent to writing Num<T> .

Your function is always returning the type of the first operant, no matter the type of the addition itself.

What you want is to deduce that type coming from the addition:

auto operator+(const Num<U>& other) -> Num<decltype(val + other.val)> {
    return val + other.val;
}

That way, it's always the right return type according to the C++ operator rules.

Answer 2

operator+ should be symmetric with respect to its arguments. It's better be implemented as a free function rather than a member function to make this symmetry explicit.

For example (using C++14 return type deduction):

template<class T, class U>
auto operator+(const Num<T>& x, const Num<U>& y) {
    using R = decltype(std::declval<T>() + std::declval<U>());
    return Num<R>{x.val + y.val};
}

std::declval<T>() is there for genericity , if T and/or U are not default constructible. If types are limited to built-in ones, like int and double , it can be replaced with T{} or T() :

using R = decltype(T{} + U{});

With class template argument deduction in C++17 it can be simplified further:

template<class T, class U>
auto operator+(const Num<T>& x, const Num<U>& y) {
    return Num{x.val + y.val};
}