habe folgendes Problem mit dem folgenden Template und Operator:

template<class T>
class A
{
public:

    T var1;

};

//===============================================
template<class T>
A<T> operator*(A<T> lhs, const T& rhs)
{
    lhs.var1 *= rhs;
    return lhs;
}

Wenn ich dann in der main ein Objekt von A erstelle ergibt der Aufruf von * mit einem double Literal keinen Fehler, mit einem int Literal schon:

int main(int argc, char** argv)
{
    A<double> a;

    // folgende Zeile ergibt keinen Compilierfehler:
    a = a * 5.0;

    // diese Zeile schon: 
    a = a * 5;
    // Die Fehlermeldung besagt, dass kein entsprechender operator* für diese Operation gefunden wurde.
}

Meine Frage ist nun, ob ich die Operatoren für int, unsigned int etc. überladen muss oder ob es eine elegante Methode für dieses cast-Problem gibt? Bzw. ob Literale von Standarddatentypen nicht vom Compiler bei Templates automatisch gecastet werden, im Gegensatz zu folgendem Beispiel ohne Template? Und wenn ja, natürlich warum?

int main(int argc, char** argv)
{
    double a;
    a = a * 5;  // wird automatisch als 5.0 vom Compiler interpretiert
    return 0;
}

Viele Grüße
FrankC++

template <typename T, typename U>
A<T> operator * (A<T> lhs, U rhs)
{
    lhs.var *= static_cast<T>(rhs);
    return lhs;
}

U muss nach T konvertiert werden können (wie bei int->double).

template<class T, class U>
A<T> operator*(A<T> lhs, const U& rhs)
{
    lhs.var1 *= rhs;
    return lhs;
}

template<class T>
class A
{
public:
    T var1;
};

template<class T>
A<T> operator*(A<T> lhs, const T& rhs)
{
    lhs.var1 *= rhs;
    return lhs;
}

...

int main(int argc, char** argv)
{
    A<double> a;

    // folgende Zeile ergibt keinen Compilierfehler:
    a = a * 5.0;

    // diese Zeile schon: 
    a = a * 5;
    // Die Fehlermeldung besagt, dass kein entsprechender
    // operator* für diese Operation gefunden wurde.
}

Meine Frage ist nun, ob ich die Operatoren für int, unsigned int etc. überladen muss oder ob es eine elegante Methode für dieses cast-Problem gibt? Bzw. ob Literale von Standarddatentypen nicht vom Compiler bei Templates automatisch gecastet werden, im Gegensatz zu folgendem Beispiel ohne Template? Und wenn ja, natürlich warum?

Ich kann dir das Buch "C++ Templates: The Complete Guide" empfehlen. Da stehen echt sehr wissenswerte Sachen über Templates in C++ drin. Deinen Code konntest du nicht kompilieren, weil die "template argument deduction" fehlgeschlagen ist. Der Compiler hat versucht einen entsprechenden Multiplikationsoperator zu finden. Das einzige, was er fand war dein Template. Allerdings müsste er erst herausfinden, was der Typparameter T eigentlich sein soll. Und da ist das Problem. Guckt er sich den ersten Funktionsparameter an, kommt er zu dem Ergebnis T=double. Guckt er sich den zweiten Funktionsparameter an, kommt er zu dem Ergebnis T=int. Diese Ergebnisse widersprechen sich allerdings, weswegen das Template ignoriert wird. Die Zahl der Konvertierungen, die in dieser Phase überhaupt betrachtet werden, sind minimal. Da dann ja nichts an möglichen Operatoren übrig bleibt, gibt es einen Fehler zur Compile-Zeit.

Ich würde dir folgendes empfehlen:

template<class T>
class A
{
public:
    T var1;

    friend A operator*(A a, T b)
    {
        a.var1 *= b;
        return a;
    }
};

Dieser Operator ist nun kein Template, es muss also auch kein Template-Argument bestimmt werden. Der Operator wird per ADL gefunden.

Alternativ kannst du die Template-Argument-Deduction auch für den zweiten Parameter effektiv abschalten:

template<class T>
struct id {typedef T type;};

template<class T>
A<T> operator*(A<T> a, typename id<T>::type b)
{
  a.var1 *= b;
  return a;
}

Hier ist id<T>::type kein sogenannter "deduzibler Kontext", weswegen der Compiler beim zweiten Parameter auch gar nicht erst versucht, zu raten, was T sein könnte. In deinem Fall würde er hier wie gewünscht, T=double herleiden und dann das Funktionstemplate für double instantiieren.

template<class T>
struct A{
    typedef T value_type; //"ich arbeite mit variablen vom Typ T"
    value_type var1;
};

//und nun geben wir dem zweiten Parameter als typ: "muss derselbe typ sein, wie die Variablen mit denen A arbeitet"
template<class T>
A<T> operator*(A<T> a, typename A<T>::value_type b)
{
  a.var1 *= b;
  return a;
}

In diesem Fall würde ich aber über ein typedef in A gehen, um klar zu machen, was T ist.

Das war klar. Dein typedef macht es schlimmer. Muss mehr lesen, um, ihn zu finden. Ist ungewöhnlicher.