Kreuzprodukt

**Moinmoin!

Vielleicht könnt ihr schlauen Köpfe mir ja weiterhelfen, denn ich verzweifle allmählich...
Meine hübsche kleine Funktion lässt sich beim besten Willen nicht kompilieren, und mir gehen allmählich die Ideen aus.

Die Aufgbabe: Implementierung des Kreuzproduktes für die gegebene Klasse Vector3D.

Vector3D:**
//--- Includes -----------------------------------------------------------------

#include <cassert>
#include <cmath>
#include "Vector3D.h"

//--- Klassenimplementierung ---------------------------------------------------

Vector3D::Vector3D()
{
setXYZ(0, 0, 0);
}

Vector3D::Vector3D(float x, float y, float z)
{
setXYZ(x, y, z);
}

float Vector3D::x() const
{
return mElement[X];
}

float Vector3D::y() const
{
return mElement[Y];
}

float Vector3D::z() const
{
return mElement[Z];
}

float Vector3D::get(int index) const
{
assert(index >= X && index <= Z);
return mElement[index];
}

void Vector3D::set(int index, float value)
{
assert(index >= X && index <= Z);
mElement[index] = value;
}

void Vector3D::setX(float value)
{

= value;

}

void Vector3D::setY(float value)
{
mElement[Y] = value;
}

void Vector3D::setZ(float value)
{
mElement[Z] = value;
}

void Vector3D::setXYZ(float newX, float newY, float newZ)
{

= newX;

mElement[Y] = newY;
mElement[Z] = newZ;
}

float Vector3D::length() const
{

* mElement[X] +

mElement[Y] * mElement[Y] +
mElement[Z] * mElement[Z]);
}

void Vector3D::normalize()
{
float scale = 1 / length();

*= scale;

mElement[Y] *= scale;
mElement[Z] *= scale;
}

Vector3D& Vector3D::operator +=(const Vector3D& rhs)
{

+= rhs.mElement[X];

mElement[Y] += rhs.mElement[Y];
mElement[Z] += rhs.mElement[Z];

return *this;
}

Vector3D& Vector3D::operator -=(const Vector3D& rhs)
{

-= rhs.mElement[X];

mElement[Y] -= rhs.mElement[Y];
mElement[Z] -= rhs.mElement[Z];

return *this;
}

Vector3D& Vector3D::operator *=(float rhs)
{

*= rhs;

mElement[Y] *= rhs;
mElement[Z] *= rhs;

return *this;
}

Vector3D& Vector3D::operator /=(float rhs)
{

/= rhs;

mElement[Y] /= rhs;
mElement[Z] /= rhs;

return *this;
}

//--- Verwandte Funktionen -----------------------------------------------------

const Vector3D operator +(const Vector3D& lhs, const Vector3D& rhs)
{
return Vector3D(lhs) += rhs;
}

const Vector3D operator -(const Vector3D& lhs, const Vector3D& rhs)
{
return Vector3D(lhs) -= rhs;
}

const Vector3D operator *(float lhs, const Vector3D& rhs)
{
return Vector3D(rhs) *= lhs;
}

const Vector3D operator *(const Vector3D& lhs, float rhs)
{
return Vector3D(lhs) *= rhs;
}

const Vector3D operator /(const Vector3D& lhs, float rhs)
{
return Vector3D(lhs) /= rhs;
}

float dot(const Vector3D& lhs, const Vector3D& rhs)
{
return lhs.x() * rhs.x() + lhs.y() * rhs.y() + lhs.z() * rhs.z();
}

Mein bisheriger Lösungsansatz:
#include <iostream>
#include <stdlib.h>
#include "Vector3D.h"

using namespace std;

int main(int argc, char *argv[])
{
float r, s, t;
float n, m, p;

Vector3D a(r, s, t);
Vector3D b(n, m, p);

Vector3D Kreuzprodukt(Vector3D a, Vector3D b);
{
float x, y, z;

x = a.y*b.z-a.z*b.y;
y = a.z*b.x-a.x*b.z;
z = a.x*b.y-a.y*b.x;

Vector3D c(x, y, z);
return c;
}
;

system("PAUSE");
return 0;
}

dein

Vector3D Kreuzprodukt(Vector3D a, Vector3D b);

kommt über main

und ich main kannst du ja

Vector3D lsg = Kreuzprodukt(a, b);

machen

du kannst nicht mitten in main eine fkt deklarieren

ich rate dir auch nicht mit unötigen kopien zu arbeiten

also
Vector3D Kreuzprodukt(Vector3D &a, Vector3D &b);

so ich muss zocken

cu

Danke! Darauf bin ich nun wirklich nicht gekommen. *schäm* ... das kommt davon wenn man andauernd zwischen den verschiedensten Sprachen hin und herspringen muss, da komm ich etwas durcheinander was wo erlaubt...

PS: noch "besser wäre"

Vector3D Kreuzprodukt(const Vector3D &a, const Vector3D &b);  // wenn das geht

Es ist zum Mäusemelken...
Meine Funktion hab ich jetzt brav innerhalb der Klasse Vector3D definiert, und der Compiler meckert ausnahmsweise mal nicht mehr mit mir.

Vector3D Vector3D::kreuz(Vector3D& a, Vector3D& b)
{

= a.mElement[Y]*b.mElement[Z]-a.mElement[Z]*b.mElement[Y];

mElement[Y] = a.mElement[Z]*b.mElement[X]-a.mElement[X]*b.mElement[Z];
mElement[Z] = a.mElement[Y]*b.mElement[Z]-a.mElement[Z]*b.mElement[Y];

return *this;
}

Dafür schimpf er jetzt wenn ich versuche die Funktion aufzurufen, und erzählt mir sie sei nicht definiert...

warum willst du eigentlich einen vector zurückgeben????

entweder

void kreuz(

und dann

Vector3D c;

c.kreuz(a,b);

dann steht es in c drinnen, oder

Vector3D kreuz(b)

Vector a,b,c;

c = a.kreiz(b);

oder wie auch immer

PS

zeig mir mal die gesamte main fkt, damit ich sehe wie und mit was du versuchst aufzurufen

Ich will deshalb einen Vector zurückgeben, weil diese kleine Funktion später noch weiterverwendet werden soll, und weil meine Aufgabenstellung das auch so verlangt

#include <iostream>
#include <stdlib.h>
#include "Vector3D.h"

using namespace std;

int main(int argc, char *argv[])
{

Vector3D a(5, 3, 0);
Vector3D b(-2, 4, 0);

cout << "Vektor a: (" << a.x() << ", " << a.y() << ", " << a.z() << ")" << endl;
cout << "Vektor b: (" << b.x() << ", " << b.y() << ", " << b.z() << ")" << endl;

Vector3D c = kreuz(a,b);

cout << "Kreuzprodukt: (" << c.x() << ", " << c.y() << ", " << c.z() << ")" << endl;

system("PAUSE");
return 0;
}

meckert der hier?

Vector3D c = kreuz(a,b);

du hast schon den operanten überladen, oder? wenn nicht, dann kannst du nicht mit = zuweisen

also am allereinfachsten machst du einen weiteren konstruktor

dann kannst du in der main

Vektor3D a,b;
...

Vektor3D c(a,b); machen

aber ich glaub das verlangt die aufgabenstellung nicht.

PS: http://www.math.uni-wuppertal.de/~axel/skripte/oop/oop13.html

newkid_ schrieb:

du hast schon den operanten überladen, oder? wenn nicht, dann kannst du nicht mit = zuweisen

Bei so einfachen Klassen (ohne dynamische Speicheranforderung) reicht der Default-Kopierkonstruktor. Hier ein Beispiel wie man das Kreuzprodukt innerhalb und ausserhalb der Klasse definieren kann.

#include <iostream>

using namespace std;

template<typename T>
class Vektor3
{
    private:
	T m_x, m_y, m_z;

    public:
	Vektor3(T x, T y, T z): m_x(x), m_y(y), m_z(z) {}
	Vektor3(T wert): m_x(wert), m_y(wert), m_z(wert) {}
	Vektor3(): m_x(0), m_y(0), m_z(0) {}

	inline T x() const { return m_x; };
	inline T y() const { return m_y; };
	inline T z() const { return m_z; };

	static Vektor3<T> KreuzProdukt(const Vektor3<T> &v1, const Vektor3<T> &v2)
	{
	    return Vektor3<T>(
		    v1.m_y*v2.m_z - v1.m_z*v2.m_y,
		    v1.m_z*v2.m_x - v1.m_x*v2.m_z,
		    v1.m_x*v2.m_y - v1.m_y*v2.m_x);
	}
};

template<typename T>
Vektor3<T> KreuzProduktVonAussen(const Vektor3<T> &v1, const Vektor3<T> &v2)
{
    return Vektor3<T>(
	    v1.y()*v2.z() - v1.z()*v2.y(),
	    v1.z()*v2.x() - v1.x()*v2.z(),
	    v1.x()*v2.y() - v1.y()*v2.x());
}

template<typename T>
ostream &operator<<(ostream &ausgabe, const Vektor3<T> &v)
{
    return ausgabe << "(" << v.x() << ", " << v.y() << ", " << v.z() << ")";
}

int main()
{
    Vektor3<float> a(2,5,7), b(4,6,8), c, d;

    c = Vektor3<float>::KreuzProdukt(a,b);
    d = KreuzProduktVonAussen(a,c);

    cout << a << endl;
    cout << b << endl;
    cout << c << endl;
    cout << d << endl;

    cin.get();
}