Nachdem ein Programmierer einen Typ als Templateargument angegeben hat, muss ich checken, ob der Typ den Zuweisungsoperator an sich selbst hat, ob der Typ die sechs Vergleichsoperatoren zu sich selbst hat und ob er acht der zehn arithmetischen Operatoren hat (kein Modulo benötigt).

Wie soll ich das machen?

Hi
Nachdem ein Programmierer einen Typ als Templateargument angegeben hat,

für ein Klassentemplate oder für ein Funktionstemplate?

EOutOfResources schrieb:

Hi
muss ich checken, ob der Typ den Zuweisungsoperator an sich selbst hat, ob der Typ die sechs Vergleichsoperatoren zu sich selbst hat und ob er acht der zehn arithmetischen Operatoren hat (kein Modulo benötigt).

Warum musst Du das machen?

EOutOfResources schrieb:

Hi
Wie soll ich das machen?

kommt drauf an, was Du damit genau erreichen willst.

Müssen tu ich es nicht. Eigentlich wollte ich "will" schreiben aber das hat zu arrogant getönt...

Das bei einem fehlerhaften Templateargument der Code trotzdem kompilierbar bleibt, indem man die Elementfunktionen, welche nichtvorhandene Operatoren des Datentypes nutzen wollen nicht vonhanden sind...

template<typename T>
class Calculator
{
public:
  T Plus(const T& l, const T& r) const
  {
    WENN_T_HAT_+_OPERATOR
    { 
      return l+r;
    }
    SONST
    {
      jaWasWillsteDennDannMachen();
      return SoTunAlsObNixWär();
    }
};

Ich habe ein Klassentemplate.

Müssen tu ich es nicht. Eigentlich wollte ich "will" schreiben aber das hat zu arrogant getönt...

Warum willst Du es denn machen? Ich verstehe immer noch nicht, was Du damit erreichen willst. Kannst Du das Problem, was Du gelöst haben willst, näher erklären?

EOutOfResources schrieb:

Das bei einem fehlerhaften Templateargument der Code trotzdem kompilierbar bleibt, indem man die Elementfunktionen, welche nichtvorhandene Operatoren des Datentypes nutzen wollen nicht vonhanden sind...

Diesen Satz verstehe ich nicht.

Das geht ja nicht. De Compiler meldet einem einen Fehler. Kann man den Code compilierbar machen, indem man die Ausführung der Elementfunktion namens "Addieren" untersagt?

Edit: noch ein Bsp hinterher

template<typename T>
class MathTraits
{
public:
    static T Addieren(const T&l, const T& r)
    {
        return l + r;
    }
};

template<typename T, typename Traits = MathTraits<T> >
class Math
{
public:
    T Addieren(const T&l, const T& r) const
    {
        return Traits::Addieren(l, r);
    }
};

template<typename T>
class VectorTraits
{
public:
    typedef std::vector<T> Vector;
    static Vector Addieren(Vector l, const Vector& r)
    {
        l.insert(l.end(), r.begin(), r.end());
        return l;
    }
};

int main()
{
    using namespace std;

    Math<std::string> m;
    cout << m.Addieren("hallo ", "welt");

    Math<std::vector<int>, VectorTraits<int> > mv;
    std::vector<int> v1(3, 1) , v2(3, 2);
    std::vector<int> v3 = mv.Addieren(v1, v2);
    std::copy(v3.begin(), v3.end(), ostream_iterator<int>(cout));

    return 0;
}

Das geht ja nicht.

Doch, das geht sehr wohl. Solange man Addieren() nicht aufruft, ist alles in Ordnung.

class Foo does not contain any function called "Addition"

statt

In function Foo::Addieren(T First, T second) with T=[non_addable]:
no matching function for call to operator+()
note: candidates are:
note: int operator+(int, int)

Wenn du die Funktion Addieren nur dann existieren lassen willst, wenn der Operator '+' vorhanden ist, musst du wohl entweder die Templates überladen oder zu SFINAE greifen

Nein. Wie Nexus gesagt hat einfach Addieren() so definieren wie es laufen soll, wenn der op+ vorhanden ist. Wenn das Templateargument keinen op+ hat, läuft der Code trotzdem, solange Addieren() nicht aufgerufen wird.
Grund: Addieren() ist als Memberfunktion eines Klassentemplates ein Funktionstemplate und wird nur dann instantiiert wenn sie aufgerufen (bzw. erwähnt) wird. Wird sie nicht aufgerufen, dann wird das Template auch nicht instantiiert und der Compiler stolpert auch nicht über den fehlenden op+