Es hört sich peinlich an aber ich habe keine Ahnung, wie ich diesen Operator ausserhalb der Klasse (also in der Source-Datei) definieren kann:

template<class T>
class Foo
{
  friend T operator+ (const T& Lhs, const T& Rhs);
};

MfG, EOutOfResources

template<class T>
T operator+ (const T& Lhs, const T& Rhs)
{
//irgentetwas tuen...
}

template<class T>
class Foo
{
  friend T operator+ (const T& Lhs, const T& Rhs);
};

korrigiert mich, wenn ich Fehler gemacht habe

mfg D3lta

Klappt das?

Was für einen Sinn soll es denn haben, wenn der Operator für T Freund-Zugriff auf deine Foo<>-Klasse hat, von der der übergebene Typ vermutlich gar nichts weiß?

Der Template-Parameter T wird später mit dem Typ der Derived-Klasse gefüllt. Aber darum geht's ja zentral beim FNI, nicht?

template<class T>
class Notequal
{
  friend bool operator!= (const T& Lhs, const T& Rhs)
  {
    return !(Lhs == Rhs);
  }
};
class MyInt : Notequal<MyInt>
{
  public:
    int Value;
    bool operator== (const MyInt& Rhs) const
    {
      return this->Value == Rhs.Value;
    }
};
int main()
{
  MyInt Foo, Bar;
  Foo == Bar; //Geht, logisch
  Foo != Bar; //Geht dank FNI
}

Hallo

Es hört sich peinlich an aber ich habe keine Ahnung, wie ich diesen Operator ausserhalb der Klasse (also in der Source-Datei) definieren kann:

template<class T>
class Foo
{
  friend T operator+ (const T& Lhs, const T& Rhs);
};

MfG, EOutOfResources

Das ist unmöglich allgemein durchführbar, da du für jedes einzelne Templateargument eine eigene Funktionsdefinition schreiben müsstest.

Und was hindert dich daran, deinen Operator direkt in der Klassendefinition zu definieren (wie in deinem Beispielcode)?

So hatte ich es ursprünglich auch aber ich wollte wissen, ob und wie man den friend -Operator in die Source-Datei packen kann.

camper schrieb:

Das ist unmöglich allgemein durchführbar, da du für jedes einzelne Templateargument eine eigene Funktionsdefinition schreiben müsstest.

Achso. Danke .