ich suche nach einer möglichkeit, wie ich eine klasse vektor3 schreiben kann, die sowohl als vek3 klasse als auch als v3 klasse zweier externer pakete interpretiert werden kann.

sprich, ich möchte funktionen externer pakete nutzen, indem ich meine eigene klasse vektor3 übergebe, ohne diese jedes mal in die vektorklassen der pakete konvertieren muss

die dümmste naive idee wäre ja:

class vector3 : public vec3, public v3...

nur speicher ich dann 9 floats für einen 3d vektor. gibt es da evtl eine bessere möglichkeit?

danke für hilfe
sas

class vektor3
{
    public:
        operator v3() const;
        operator vec3() const;
};

Wenn du sagen kannst, dass zwischen deiner Klasse und einer der anderen Vektoren eine IST-EIN-Beziehung besteht, kannst du von dieser ableiten und den entsprechenden Cast-Operator weglassen. Dazu weiss ich jetzt allerdings zu wenig über dein Problem...

mir ist nur nicht ganz so klar, wie ich das einsetzen soll.

so etwa?

operator v3() const {
return v3(myX, myY, myZ);
}

?

wird dann nicht bei jedem schritt ein cast durchgeführt? (Was ich ja vermeiden wollte ursprünglich)

mir ist nur nicht ganz so klar, wie ich das einsetzen soll.

so etwa?

operator v3() const {
return v3(myX, myY, myZ);
}

Ja, genau.

sastrian schrieb:

wird dann nicht bei jedem schritt ein cast durchgeführt? (Was ich ja vermeiden wollte ursprünglich)

Es wird ein Cast durchgeführt, wenn ein Objekt von vektor3 in einem Kontext auftritt, in dem es als v3 interpretiert werden kann.

Aber eben, im Zweifelsfalle nimmst du besser eine Methode:

v3 ToVector3() const
{
    return v3(myX, myY, myZ);
}

wenn ich das so mache, wie oben beschrieben

operator v3() const {
    return v3(myX, myY, myZ);
}

kommt käse bei raus, da der neu erzeugte v3 vektor am ende der funktion wech ist.
löse ich das mit nem new aufruf

operator v3() const {
    v3 * vec = new v3(myX, myY, myZ);
    return *vec;
}

habe ich ein problem, dass er nie wieder gelöscht wird, wenn ich diesen vektor irgendwo übergebe

externespaket.externefunktion(myVec);

wobei myVec meine vektorklasse ist und vom externen paket die v3 klasse erwartet wird. es kompiliert und macht auch alles richtig, nur hab ich ein memorybug dadurch drinnen, weil der mit new erzeugte vektor nie wieder richtig entfernt wird und von mir auch nicht mehr entfernt werden kann oder?

danke nochmals

Aber wieso soll meine Version zu Käse führen? Das Objekt wird kopiert und existiert natürlich nur temporär. Normalerweise weist man Werte aber einer Variable zu, wenn man sie speichern will...

vektor3 AlterVektor;
v3 NeuerVektor = AlterVektor;

der aufruf ist ja folgender:

externesv3Paket.externev3Funktion(meinVec)

externev3Funktion erwartet ja ein v3 und nicht ein vector3 (meinVec ist vom Typ vector3)

beimn casten von meinVec existiert das Objekt nur temporär und ist innerhalb der externev3Funktion nicht mehr vorhanden, also null und daher mit komischen werten

hoffe das ist nicht zu verwirrend^^

danke nochmals.

hier der bisherige gesamte code

#ifndef _HC_VEC_H_
#define _HC_VEC_H_

#include <Ogre.h>
#include <Common/Base/hkBase.h>

class hcVec
{

public:

	float x;
	float y;
	float z;

	hcVec() {
		x = 0;
		y = 0;
		z = 0;
	};

	hcVec(float xx, float yy, float zz)
	{	
		x = xx;
		y = yy;
		z = zz;
	};

	hcVec(Ogre::Vector3 &other) {
		x = other.x;
		y = other.y;
		z = other.z;
	};

	hcVec(hkVector4 &other) {
		x = other(0);
		y = other(1);
		z = other(2);
	};

	operator Ogre::Vector3&() const {
		Ogre::Vector3 * newVec = new Ogre::Vector3(x, y, z);
		return *newVec;
	};

	operator hkVector4&() const {
		hkVector4 * newVec = new hkVector4(x, y, z);
		return *newVec;
	};

	hcVec& operator =(const Ogre::Vector3 &vec) {
		x = vec.x;
		y = vec.y;
		z = vec.z;

		return *this;
	};

	hcVec& operator =(const hkVector4 &vec) {
		x = vec(0);
		y = vec(1);
		z = vec(2);

		return *this;
	};

};

#endif

mit dem Beispielaufruf

hcVec vec(4, 3, -2);

	Ogre::Vector3 example(2,2,2);
	hcVec res = example.crossProduct(vec);

beimn casten von meinVec existiert das Objekt nur temporär und ist innerhalb der externev3Funktion nicht mehr vorhanden, also null und daher mit komischen werten

Temporär heisst hier während der Lebenszeit des gesamten Ausdrucks, also auch über die ganze Zeit des Funktionsaufrufs hinweg. Wird da innerhalb von Ogre noch etwas Komisches gemacht? Schau mal mit dem Debugger, bis wo das Objekt gültig ist und noch brauchbare Werte besitzt.

Du solltest ausserdem Initialisierungslisten bei Konstruktoren und Const-Referenzen anstatt Referenzen als Parameter verwenden.