template <class t, unsigned int n>
class T
{
  private:
    t data[n]; //datenfeld
  public:
    operator const t* () const; // cast in (t*)
    T<t,n> operator - (const T<t,n>& r); // - operator
//...
};
//...
class T2: virtual public T<float, 3>
{
//...
};
//...
T2 var1, var2;
//...
T2 var3 = var1 - var2; //Anweisung mit falschem Operator aufruf

das problem was bei mir jetzt auftritt ist das er nicht den -operator aufruft sondern den cast-operator und ich hab keinen blassen warum. das interessante ist wenn ich den -operator aus der klasse auslagere, also

template <class t, unsigned int n>
T<t,n> operator - (const T<t,n>& l, const T<t,n>& r); // - operator ausgelagert

dann wird der -operator bei der anweisung aufgerufen.
vllt hat ja jemand eine idee. danke schonmal im voraus.

Ich vermute mal da gibts sowas wie

T(const t* pt);

Wenn ja, mach den mal explicit.

T(const T<t,n>& src);

wie der Name schon andeutet, hilft Dir ein impliziter Konstruktor nicht weiter, wenn Du ein "explicit" (keyword) brauchst

Gruß,

Simon2.

naja, implizit gibts diesen vllt schon, da ich einen copy-constructor definiert habe.

T(const T<t,n>& src);

Der Konstruktor passt eigentlich nicht.

Ich hatte schon an sowas wie

T(const t* pt)

gedacht.

Das gibt dann mit dem Cast-Operator nämlich

T2 var3(float* + float*);
/*
float* implizit durch Cast-Operator fuer var1 und var2 erzeugt, und in passenden Konstruktor
T2(float* pt) eingesetzt.
*/

Ich habe die Casts hier mal extra explizit ausgeführt. In Deinem würde das natürlich alles implizit passieren.
Der resultierende Zeiger zeigt zwar vermutlich ins Nirvana, aber trotzdem ist das (sofern ich es nicht verpeilt habe) ein gültiger Ausruck.
Mach entweder den Cast oder den Konvertierungskonstruktor (sofern er wirklich existiert) mal explicit.
Der Cast-Operator sollte eigentlich auch zwei mal aufgerufen werden. Ist das so?

PS: Ich habe keinen Schnall, ob das wirklich so abläuft. Das ist nur eine vage Vermutung.

Das gesamte Interface der Klasse wäre allerdings schon hilfreich.

für T gibts folgende Konstruktoren und interne Operatoren:

T();
T(const T<t, n>& src);
void operator = (const T<t, n>& src);
operator const t* () const;
T<t,n> operator - (const T<t,n>& r);

für T2 gibts folgende Konstruktoren und interne Operatoren:

T2(float x = 0, float y = 0, float z = 0);
T2(const T<float, 3>& src);
void operator = (const T<float, 3>& src);

und T2 ist wie gesagt von T abgeleitet also:

class T2 : virtual public T
{//...
};

und ja er ruft bei der Anweisung zweimal den Cast-Operator auf und scheint die dann voneinander abzuziehen, warum auch immer das geht.

Ich behaupte allerdings, das hier noch eine weiter Deklaration stört. Jedenfalls ruft mein Compiler hier nicht den Konvertierungsoperator auf.

#include <iostream>
using namespace std;

template <class t, unsigned int n>
class T
{
private:
    t* data[n];
public:
    T() { cout << "T::T()" << endl; }
    T(const T<t, n>& src) { cout << "T::T(const T&)" << endl; }
    void operator = (const T<t, n>& src) { cout << "void T::operator=(const T&)" << endl; }
    operator const t* () const { cout << "T::operator const t*()" << endl; return data; }
    T<t,n> operator - (const T<t,n>& r) { cout << "T T::operator-(const T&)" << endl; return *this; }
};
class T2: virtual public T<float, 3>
{
public:
    T2(float x = 0, float y = 0, float z = 0) { cout << "T2::T2(float=0,float=0,float=0)" << endl; }
    T2(const T<float, 3>& src) { cout << "T2::T2(const T<float,3>&)" << endl; }
    void operator = (const T<float, 3>& src) { cout << "coid T2::operator=(const T<float,3>&)" << endl; }
};

int main()
{
    T2 var1, var2;

    T2 var3 = var1 - var2;
}

T2(float x = 0, float y = 0, float z = 0);

Die Differenz der beiden Zeiger liefert ein Int, und der passt zu dem oben stehenden Konstruktor. Irgendwie ziemlich böse.
Wieso dabei aber das ganze implzite Geknispel dem direkt passenden Wert vom Subtraktions-Operator vorgezogen wird, ist mir schleierhaft.
Setzte in dem obenstehenden Konstruktor mal eine Ausgabe ein. Ich schätze mal der wird aufgerufen.

explicit als Schlüsselwort mit rein (Google hilft )
Mir ist nur Schleierhaft, wieso das Casten und implizite Umwandeln von int nach float dem direkt passenden operator- und dem Copy-Konstruktor vorgezogen wird. Bei mir ist das nicht so.

es ist aucht nicht so. Wenn das ein vereinfachtes Beispiel ist, gehe ich davon aus, dass sich beim Vereinfachen ein Fehler eingeschlichen hat.

T2 var3 = var2 - var1;

das funktioniert jetzt nicht mehr, warum auch nicht?
weil es gibt ja den copy-constructor über die klasse T, der das eigentlich abwickeln sollte.

beim vereinfachen ist kein fehler passiert, habe es gerade nochmal durchgeschaut.

Dann sollte es sich aber nicht anders verhalten. Welchen Compiler setzt du denn ein?

also ich hab mir jetz mal das mit explicit angeschaut, allerdings hab ich jetz ein anderes problem. nämlich:

T2 var3 = var2 - var1;

das funktioniert jetzt nicht mehr, warum auch nicht?
weil es gibt ja den copy-constructor über die klasse T, der das eigentlich abwickeln sollte.

Was heißt funktioniert nicht? Fehlermeldung des Compilers? wenn ja, welche? Im Übrigen sind hier zwei Konstruktoren von T2 beteiligt und die von T eigentlich nur als Teil dieser anderen Konstruktoren.

error C2440: 'initializing' : cannot convert from '__w64 int' to 'T2' Constructor for class 'T2' is declared 'explicit'

weil ich jetzt den einen constructor explizit gemacht habe

explicit T(float x = 0, float y = 0, float z = 0, float v = 0);

also er konvertiert var1 und var2 immernoch in (t*)

also gedacht war das ja so, das ich die operatoren in T definiere und in T2 mitverwenden kann, weswegen bei var1 - var2 eigentlich was temporäres von Typ T<float, 3> rauskommen sollte und das sollte dann als argument für den anderen constructor bei der Klasse T2 genommen werden.

das problem ist außerdem noch, das wenn ich statt

T2 var3 = var1 - var2;

jetzt

T2 var3(var1 - var2);

schreibe dann nimmt er auch den expliziten constructor von T2 und subtrahiert wieder die zeiger voneinander.

beim vereinfachen ist kein fehler passiert, habe es gerade nochmal durchgeschaut.
also ich hab mir jetz mal das mit explicit angeschaut, allerdings hab ich jetz ein anderes problem. nämlich:

T2 var3 = var2 - var1;

das funktioniert jetzt nicht mehr, warum auch nicht?
weil es gibt ja den copy-constructor über die klasse T, der das eigentlich abwickeln sollte.

Ich wage mal zu behaupten, daß dann Dein Copy-Konstruktor nicht in Ordnung ist, bzw. nicht existiert. Oder aber Dein operator- gibt einen falschen Typ zurück.

//falscher Parameter oder nicht vorhanden
T2(const T<float, 3>& src);
//bzw.
//gibt falschen Typ zurück.
T<t,n> operator - (const T<t,n>& r);

Offensichtlich scheint die Adressdifferenz, die durch das Subtrahieren der Zeiger entsteht, die einzige Variante zu sein, für die ein gültiger Konstruktor existiert (der jetzt aber explicit deklariert wurde).

T2(const T<float, 3>& src);

den Cast in (t*) brauch ich in dem programm, weil es bei mir funktionen gibt die diesen typ als argumenttyp haben, aber das ist ja für das problem irrelevant. der cast liefert quasi den zeiger der internen variable

t data[n];

das sind aber wie gesagt alles nur details.

(wenn du an anderer Stelle unbedingt einen t* benötigst, ist vielleicht eine explizite Umwandlungsfunktion 't* data()' geeigneter als ein Umwandlungsoperator)

Aber genau dieser Cast scheint das Problem zu sein, weil jetzt außer deinem op- auch der eingebaute op- für Zeiger in Frage kommt für diesen Ausdruck Wie gesagt, lass mal testweise diesen Operator weg.

Aber der Cast DARF kein Problem sein, denn es ist standardisierte Regel, daß den passenden Typen priorität vor den implizit umzuwandelnden Typen eingeräumt wird. Selbst der eklige und antike MSVC 6.0 hier in der Firma macht das korrekt.
Ich schätze mal, daß nach wie vor entweder im Rückgabewert von operator- oder im Copy-Konstroktor ein Bock ist, und der Typ eben nicht passt ( vielleicht das kleine t vom Template-Type mit dem großen T der Klasse vertauscht o.ä.). Die Tatsache, daß es plötzlich gar keinen passenden Konstruktor mehr gibt, wenn man den Konvertierungskonstruktor mit den drei Float-Argumenten als explicit deklariert, ist ein weiteres Indiz dafür.

explicit T2(float x = 0, float y = 0, float z = 0);
T2(const T<float, 3>& src);
T2(const T2& src);

dennoch findet er bei der anweisung

T2 var1, var2;
//...
T2 var3 = var1 - var2;

keinen passenden Konstruktor