Das folgende Beispiel definiert eine grundlegende Containerklasse vom Typ pod. Mit dieser Klasse werden dann eine Reihe von Typedefs erstellt, die eine OOP-Version des Basis-Podtyps darstellen. Das Problem entsteht, wenn wir anfangen, diese Typen einander zuzuweisen.

Ich habe versucht, den Operator als Friend-Methode mit lhs- und rhs-Argumenten zu definieren, indem ich einfache PodObjects als Typ verwendet habe, aber ohne Erfolg. Gibt es jemanden, der etwas Ähnliches erlebt hat oder eine andere Lösung für dieses Problem kennt.

Danke im Voraus.

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

Ergebnisse in einer Compiler-Ausgabe:

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

BEARBEITEN:

Die folgende Freundschaftsmethode erledigt den Job für mich:

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