template <class T>
class Koordinate2D : public Koordinate<T>{
public:
void operator+(Koordinate2D<T>& K){;}
};

int main (int argc, char *argv[])
{
Koordinate2D<double> p1(1,2) ;
}
----------------------------------------------------------------------
folgende Fehlermeldung(Visual Studio)
Instanz von abstrakter Klasse kann nicht erstellt werden
1> with
1> [
1> T=double
1> ]
1> aufgrund folgender Member:
1> "void Koordinate<T>::add(Koordinate<T> &)": ist abstrakt
1> with
1> [
1> T=double
1> ]

operator+ in wird nur überschrieben, wenn er die gleiche Signatur wie in der Basisklasse hat. Schau nochmal genau hin: das Argument ist einmal Koordinate und einmal Koordinate2D. Du könntest als Parameter einen Zeiger auf Koordinate übergeben und dann innerhalb von operator+ hochcasten, das sollte gehen. Ob das aber sinnvoll ist und ob es überhaupt sinnvoll ist operator+ als Schnittstelle zu definieren, das müssen dir andere sagen. Ich denke eher nein. Stattdessen würde ich jeder abgeleiteten Klasse eine friend-Methode operator+ spendieren...

class Base
{
public:
  Base* Create() = 0;
};

class Derived : Base
[
public:
  Derived* Create() { return new Derived(); }
};

Gelten als Signatur bei zu implementierenden virtuellen Methoden in Subklassen nicht auch "kompatible" Paramter , also z.B SubTypen der MethodenParamter der virtuellen Methode ? Hab sowas ähnliches mal in nem Buch gelesen glaub ich , bin mir aber nicht mehr sicher auf welche Teile der Signatur das bezogen war...

Du musst eine rein virtuelle Methode so überschreiben, wie sie in der Basisklasse deklariert ist. Schließlich kann es ja sein, dass du Koordinate2D<T>::operator+(Koordinate<T>&) und Koordinate2D<T>::operator+(Koordinate2D<T>&) verschieden implementieren willst. Was du meinst ist eher, dass bspw. so ein Aufruf gültig ist:

void compute(B* b);

class B
{
};

class D : public B
{
};

int main()
{
    D* d = new D();
    compute(d);
}

Hier wäre D ein kompatibler Typ weil er von B abgeleitet ist.