Sobrecarga del operador de la plantilla de C ++ con diferentes tipos

El siguiente ejemplo define una clase de contenedor podtype básico. Usando esta clase, se crean una serie de typedefs que representan una versión OOP del podtype básico. El problema se origina cuando comenzamos a asignar esos tipos entre sí.

Intenté definir el operador como método amigo con los argumentos lhs y rhs usando PodObjects simples como tipo pero sin éxito. ¿Hay alguien que podría haber experimentado algo similar o conoce alguna otra solución para este problema?

Gracias por adelantado.

#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;
}

Resultados en un compilador de salida:

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){

EDITAR:

El método de amigo a continuación hace el trabajo por mí:

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