Fehler: Template-Klasse, globaler Operator, Pointer

bluecode

hi,

ich hab eine Template-Klasse Vector. Nun möchte ich, dass ich durch einen globalen Operator zwei solche Klassen addieren kann. Diesem Operator sollen aber nur Pointer auf die Klasse übergeben werden und er soll auch nur einen Pointer auf einen neuen Vektor zurückgeben. Ich habs wie folgt gemacht:

template<class T>
const class Vector<T, 3> *operator + (const class Vector<T, 3> *v1, const class Vector<T, 3> *v2)
	{
        /*...*/
	}

nun kommt egal wie ichs mach beim kompilieren folgender Fehler (Dev-C++):
const Vector<T, 3u> operator+(const Vector<T, 3u>, const Vector<T, 3u>)' must have an argument of class or enumerated type.***

Wenn ich das ganze ohne Pointer mach funktioniert es wunderbar:

template<class T>
const class Vector<T, 3> operator + (const class Vector<T, 3> v1, const class Vector<T, 3> v2)
	{
        /*...*/
	}

Danke im voraus!

audacia

bluecode schrieb:

nun kommt egal wie ichs mach beim kompilieren folgender Fehler (Dev-C++):
const Vector<T, 3u> operator+(const Vector<T, 3u>, const Vector<T, 3u>)' must have an argument of class or enumerated type.***

Du kannst keine globalen Operatoren mit zwei Zeigerargumenten überladen. Nimm Referenzen, genau dafür gibt es die.

Moritz

bluecode

Danke für die schnelle Antwort.

Heißt das, dass ich, wenn ich nur Pointer auf eine Klasse habe und addieren möchte zuerst dereferenzieren muss? Also so:

class Vector<T, dim> *v1 = new Vector<T, dim>();
class Vector<T, dim> *v2 = new Vector<T, dim>();
class Vector<T, dim> *v3 = new Vector<T, dim>();
*v3 = *v1 + *v2;

audacia

bluecode schrieb:

Heißt das, dass ich, wenn ich nur Pointer auf eine Klasse habe und addieren möchte zuerst dereferenzieren muss?

Ja (du kannst allerdings sicher sein, daß das keinen Performancenachteil darstellt, da eine Referenz intern durch einen Zeiger dargestellt wird und die Dereferenzierung nur syntaktisch eine Rolle spielt).

Moritz

bluecode

audacia schrieb:

...da eine Referenz intern durch einen Zeiger dargestellt wird ...

Muss ich dann v3 vorher erstellen (mit new Vector-Klasse erzeugen) oder muss ich innerhalb des Operators eine neue Vector-Klasse erstellen und den Pointer dann zurückgeben?

Also so:

template<class T>
class Vector<T, 3> operator + (const class Vector<T, 3> &v1, const class Vector<T, 3> &v2)
    {
    return Vector<T, 3>(/*...*/);
    }
/*...*/
Vector<T, 3> *v1 = new Vector<T, 3>(/*...*/);
Vector<T, 3> *v2 = new Vector<T, 3>(/*...*/);
Vector<T, 3> *v3 = new Vector<T, 3>(/*...*/);
*v3 = *v1 + *v2;

oder so:

template<class T>
class Vector<T, 3> operator + (const class Vector<T, 3> &v1, const class Vector<T, 3> &v2)
    {
    return *(new Vector<T, 3>(/*...*/));
    }
/*...*/
Vector<T, 3> *v1 = new Vector<T, 3>(/*...*/);
Vector<T, 3> *v2 = new Vector<T, 3>(/*...*/);
Vector<T, 3> *v3;
*v3 = *v1 + *v2;

audacia

bluecode schrieb:

Also so:

template<class T>
class Vector<T, 3> operator + (const class Vector<T, 3> &v1, const class Vector<T, 3> &v2)
    {
    return Vector<T, 3>(/*...*/);
    }
/*...*/
Vector<T, 3> *v1 = new Vector<T, 3>(/*...*/);
Vector<T, 3> *v2 = new Vector<T, 3>(/*...*/);
Vector<T, 3> *v3 = new Vector<T, 3>(/*...*/);
*v3 = *v1 + *v2;

oder so:

template<class T>
class Vector<T, 3> operator + (const class Vector<T, 3> &v1, const class Vector<T, 3> &v2)
    {
    return *(new Vector<T, 3>(/*...*/));
    }
/*...*/
Vector<T, 3> *v1 = new Vector<T, 3>(/*...*/);
Vector<T, 3> *v2 = new Vector<T, 3>(/*...*/);
Vector<T, 3> *v3;
*v3 = *v1 + *v2;

Ersteres (da kümmert sich der Compiler um die Speicherverwaltung; das zweite erzeugt erst einen neuen Vector per new und kopiert ihn dann, hier würde also ein Objekt unnötig erzeugt und danach nie wieder freigegeben).
/Edit: hab mir das zweite Code-Snippet nicht richtig durchgelesen (ändert aber an der Entscheidung natürlich nichts)

Moritz

bluecode

Danke