C++ template-operator überladen mit verschiedenen Arten

Beispiel unten definiert eine grundlegende podtype-container-Klasse. Die Verwendung dieser Klasse eine Reihe von Typdefinitionen werden dann erstellt, die darstellen eine OOP version des basic podtype. Das problem entsteht, wenn wir die Zuordnung dieser Typen zu den anderen.

Habe ich versucht zu definieren, die der operator als friend-Methode mit lhs und rhs-Argumente mit klarem PodObjects als Typ, aber ohne Erfolg. Gibt es jemanden, der vielleicht etwas erlebt, was ähnlich oder kennt eine andere Lösung für dieses problem.

Vielen Dank im Voraus.

#include <stdint.h>

template <typename T>
class PodObject {
protected:
    T _value;

public:
    PodObject<T>(int rhs) {
        this->_value = static_cast<T>(rhs);
    }   

    PodObject<T> operator+= (PodObject<T> const &rhs){
        this->_value = rhs._value;
        return *this;
    }   
};  

typedef PodObject<int8_t> Int8;
typedef PodObject<int16_t> Int16;

int main() {
    Int16 a = 10; 
    Int8 b = 15; 

    a += b; //Source of problem
    return 0;
}

Führt zu einem compiler-output:

example.cpp:26:11: error: no viable overloaded '+='
        a += b;
        ~ ^  ~
example.cpp:13:22: note: candidate function not viable: no known conversion from 'Int8' (aka 'PodObject<int8_t>') to 'const PodObject<short>'
      for 1st argument
        PodObject<T> operator+= (PodObject<T> const &rhs){

---

EDIT:

Die Freund-Methode unten macht den job für mich:

template<typename U, typename W>
friend PodObject<U> operator+= (PodObject<U> &lhs, PodObject<W> const &rhs) {
    lhs._value += rhs._value;
    return lhs;
}