Optimering af classes/structs

Jeg er igang med at lave et lille fysik-library, hvor jeg vil kunne lave nogle simulationer af realistisk fysik.

Jeg starter i det helt simple med en Vector-struct med hvilken jeg skal kunne lave nogle forskellige regneoperationer. I programmet kommer jeg til at lave en hel del af disse Vector-operationer, så det skal helst gå så hurtigt som muligt - inden for de rammer, der nu er når jeg bruger structs med member funktioner og operator overload.

Spørgsmål 1: Bliver non-member funktioner eksekveret langsommere end member funktioner?

struct Vector {
	float x, y, z;
	// constructors

	Vector(float x, float y) : x (x), y (y) {};
	Vector(float x, float y, float z) : x (x), y (y), z (z) {};

	// member funktion
	const Vector operator*(const float &MultiplicateFloat) {
		return Vector(x * MultiplicateFloat, y * MultiplicateFloat, z * MultiplicateFloat);
	}
};

// non-member funktion
Vector operator*(const float &MultiplicateFloat, Vector &MultiplicateVector) {
	return Vector(MultiplicateVector.x * MultiplicateFloat, MultiplicateVector.y * MultiplicateFloat, MultiplicateVector.z * MultiplicateFloat); // løsning 1
	// eller løsning 2 return MultiplicateVector*MultiplicateFloat;
}

Samtidig overvejer om løsning 1 er hurtigere (hvilket jeg tror) end løsning 2 i non-member funktionen.

Hvis det er tilfældet at non-member funktionen bliver eksekveret langsommere vil det jo være hurtigere at skrive
Vector*2 end 2*Vector - hvilket for mig er en smule irriterende.

Spørgsmål 2: Kald af allerede definerede operatorer i forhold til redefinition. Betragt nedenstående kode og kommentarer:

struct Vector {
	float x, y, z;

	// constructors
	Vector(float x, float y) : x (x), y (y) {};
	Vector(float x, float y, float z) : x (x), y (y), z (z) {};

	// operators
	Vector operator+(const Vector &AddVector) {
		return Vector(x + AddVector.x, y + AddVector.y, z + AddVector.z);
	}

	Vector operator-(const Vector &SubtractVector) {
		return Vector(x - SubtractVector.x, y - SubtractVector.y, z - SubtractVector.z);
	}

	Vector operator-() {
		return Vector(-x, -y, -z); // løsning 1
		return Vector(0,0,0) - *this; // løsning 2
	}

	const Vector operator*(const float &MultiplicateFloat) {
		return Vector(x * MultiplicateFloat, y * MultiplicateFloat, z * MultiplicateFloat);
	}

	Vector operator*=(const float &MultiplicateFloat) {
		// løsning 1:
		x *= MultiplicateFloat;
		y *= MultiplicateFloat;
		z *= MultiplicateFloat;
		
		*this = *this*MultiplicateFloat // løsning 2
	}

	float operator*(const Vector &OtherVector) {
		return x * OtherVector.x + y * OtherVector.y + z * OtherVector.z;
	}

	float Length() {
		return sqrt(x * x + y * y + z * z); // løsning 1
		return sqrt((*this)*(*this)); // løsning 2
	}
};

Løsning 2 er genbrugen af de allerede definerede operatorer - men jeg overvejer om kaldet af disse vil være langsommere end at definere løsningen direkte (løsning 1).
Løsning 2 er en del mere behænding men hvis den er langsommere...

På forhånd tak. (desværre har jeg ikke flere point jeg kan udlove :/ )

qff