перегрузка операторов шаблонами

Question

У меня есть класс, который должен быть в состоянии удерживать тип float, double, long excetera. Я хотел бы перегрузить его таким образом, чтобы он мог добавить два экземпляра, содержащих разные типы.

template <typename T>
class F{
public:
       F(const T & t){a=t;}
       T a;
       F & operator+= (const F & rhs);
}

template<typename T>
F<T> F::operator+= (const F & rhs){
       a+=rhs.a;
       return *this

Это просто псевдокод, который я сохранил ненужные биты, где я на самом деле пытаюсь использовать такого рода решение.

Теперь при попытке использовать:

  F<int> first(5);
  F<int> second(4);
  first+=second; // Works

  F<int> third(5);
  F<float> fourth(6.2);
  fourth+=third; // wont work

Я понимаю, почему это не работает, поскольку предполагается, что аргумент rhs имеет тот же тип, что и lhs. Я также вижу, что есть потенциальные проблемы при выполнении операции, которая имеет тип int + = long, так как если long является большим, тип должен будет измениться. То, что я не могу найти, это хороший способ решить проблему. Буду признателен за ваш вклад. Спасибо

Answer 1

Вам также необходимо сделать operator+= шаблон:

template <typename T>
class F{
public:
       F(const T & t){ a = t; }
       T a;

       template<typename T2>
       F& operator+=(const F<T2>& rhs);
}; // semicolon was missing

template<typename T>
template<typename T2>
F<T>& F<T>::operator+=(const F<T2>& rhs) {
       a += rhs.a;
       return *this; // semicolon was missing
} // brace was missing

Тогда вы можете сделать

F<int> a(4);
F<float> b(28.4);

b += a;

cout << b.a << endl; // prints 32.4

Вот рабочий пример .

Answer 2

    template <typename T>
    class F{
    public:
           F(const T & t){a=t;}
           T a;
           template<typename T2>
           F & operator+= (const F<T2> & rhs);
    };

    template<typename T>
    template<typename T2>
    F<T>& F<T>::operator+= (const F<T2> & rhs){
           a+=(T)rhs.a;
           return *this
    }

РЕДАКТИРОВАТЬ:

исправлена ​​ошибка, см. Комментарии

Answer 3

Вы можете шаблонизировать operator+=:

template<typename G> F<T> & operator+= (const F<G> & rhs);

... при условии, что вы можете каким-то образом преобразовать G в T.