Klasse mit Methode, die mehrere Objekte der Klasse beinhaltet



  • Hallo,
    ich steh jetzt kurz vor der Prüfung und "programmiere" (-hust-) immernoch sehr verwirrend.

    Ich hab einfach mal etwas mit Klassen herumgespielt, und bin an einem Punkt gekommen, der mich etwas verwirrt.
    Soweit funktioniert anscheinend was ich da fabriziert habe, aber was mich stört ist das ich zusätzlich-(Dummy-?!)-Objekte anlegen muss?!

    Ich hab mir eine Koordinaten-Klasse angelegt und wollte ein paar Standartoperationen ausprobieren.
    Bei dem Skalarprodukt und dem Spatprodukt weiß ich nicht, wie ich die Methode aufrufen kann, ohne doofe
    zusätzliche Objekte anzulegen... Aber das angezeigte Ergebnis stimmt.

    Hier mal ein kurzer Überblick (wichtig ist eig. nur der Methodenaufruf in der main.cpp):
    Koordinaten.h:

    #ifndef Koordinaten_H
    #define Koordinaten_H
    
    class Koordinaten
    {
    	private:
    		int x;
    		int y;
    		int z;
    	public:
    		Koordinaten(int, int, int);
    		int getx();
    //...
    		Koordinaten kreuzprodukt(Koordinaten, Koordinaten);
    		long int skalar(Koordinaten, Koordinaten);
    		long int spat(Koordinaten, Koordinaten, Koordinaten);
    };
    
    #endif
    

    Koordinaten.cpp:

    #include "Koordinaten.h"
    #include <iostream>
    
    Koordinaten::Koordinaten(int a, int b, int c)
    {
    	x=a;
    	y=b;
    	z=c;
    } 
    
    int Koordinaten::getx()
    {
    	return x;
    }
    
    //...
    long int Koordinaten::skalar(Koordinaten k1, Koordinaten k2)
    {
    	int skalar;
    	skalar = (k1.getx()*k2.getx())+(k1.gety()*k2.gety())+(k1.getz()*k2.getz());
    	return skalar;
    }
    
    long int Koordinaten::spat(Koordinaten k1, Koordinaten k2, Koordinaten k3)
    {
    	int a=1;
    	int b=1;
    	int c=1;
    	long int spat;
    	a=(k2.gety()*k3.getz())-(k2.getz()*k3.gety());
    	b=(k2.getz()*k3.getx())-(k2.getx()*k3.getz());
    	c=(k2.getx()*k3.gety())-(k2.gety()*k3.getx());
    	spat = (a*k1.getx())+(b*k1.gety())+(c*k1.getz());
    	return spat;	
    }
    

    main.cpp:

    #include <iostream>
    #include "Koordinaten.h"
    #include <cmath>
    
    using namespace std;
    
    int main()
    {
    	Koordinaten k1(1, 2, 3);
    	Koordinaten k2(2, 3, 4);
    	Koordinaten k3(3, 4, 5);
    	Koordinaten k4(1, 1, 1);      //<--("Dummy-")Objekt?!
    	Koordinaten k5(1, 1, 1);     //<--("Dummy-")Objekt?!
    	cout << "Skalarprodukt: " << k4.skalar(k1, k2) << " und das Spatprodukt: " << k5.spat(k1, k2, k3);   //zur Verwendung hier
    	cin.sync();
    	cin.get();
    	return 0;
    }
    

    P.S.: Sorry wegen "using namespace std;" ... ich weiß was namespace so alles machen kann... war in Eile zusammengecodet 😃



  • Naja, du musst dann halt deine API anders designen.
    z.B. bei skalar nur ein Koordinaten Objekt übergeben lassen und this als zweites benutzen.



  • Ahh, stimmt, *this 😃
    Ok, das wär natürlich einiges schicker..
    Danke schon mal 🙂



  • Meine persönliche Meinung, ich würde Skalarprodukt etc. als freistehende Funktionen programmieren. Koordinate/Vector3 als const X& übergeben (finde 3 integer schon fast grenzwertig zu kopieren, oder?). Ich würde auch überlegen ein struct zu verwenden und x, y, z public zu lassen. Als template würde sich eine solche Klasse auch gut eignen (falls das nicht zu weit reicht).



  • Noch was anderes: das Spatprodukt ist doch (a×b)c(\vec a \times \vec b) \cdot \vec c - du hast doch die beiden Funktionen Kreuzprodukt und Skalarprodukt schon in der Klasse drin. Da böte es sich doch an, für die Berechnung des Spatproduktes diese Funktionen wiederzuverwenden!

    Für das Skalarprodukt böte sich auch alternativ noch an, operator* zu überladen. Sowohl bei dem Skalar- als auch bei dem Kreuzprodukt finde ich es diskussionswürdig, ob die frei oder als Member implementiert sein sollten.

    Je weniger sie mit *this zu tun hat, desto eher sollte man als freie Funktion implementieren. Es ist letztendlich so ein bisschen die Frage der Lesbarkeit (da sind member-Funktionen besser, finde ich; a.cross(b)*c finde ich leichter lesbar als scalarproduct(cross(a, b), c)) sowie der Kapselung (freie Funktionen sind da besser, finde ich, weil sie nicht auf private member zugreifen können). Und zuletzt komme ich noch mit einem völlig bescheuerten Grund: im Editor kann ich "a." tippen und sehe dann die Liste der Memberfunktionen. Bei freien Funktionen muss ich mich immer an den Namen erinnern - und darin bin ich schlecht.



  • @marco_der_noob sagte in Klasse mit Methode, die mehrere Objekte der Klasse beinhaltet:

    Soweit funktioniert anscheinend was ich da fabriziert habe, aber was mich stört ist das ich zusätzlich-(Dummy-?!)-Objekte anlegen muss?!

    class foo
    {
        foo();
        foo(int, int, int);
    };
    

    Es sollte so möglich sein, z.B. einfach foo k4;anstatt foo k4(1, 1, 1);zu schreiben.

    long int Koordinaten::skalar(Koordinaten k1, Koordinaten k2)
    {
    	int skalar;
    	skalar = (k1.getx()*k2.getx())+(k1.gety()*k2.gety())+(k1.getz()*k2.getz());
    	return skalar;
    }
    

    Wieso nicht

    long int Koordinaten::skalar(Koordinaten k1)
    {
    	int skalar;
    	skalar = (x*k1.getx())+(y*k1.gety())+(z*k1.getz());
    	return skalar;
    }
    

    Dann sollte

    auto k4 = k1.skalar(k2);
    

    möglich sein.



  • Wenn dann aber konsequent entweder die get-Funktionen benutzen oder aber direkt auf die Member zugreifen (nicht mixen).



  • @th69 Also in einer Memberfunktion per Getter-Funktion eine Kopie der (privaten) Membervariablen in der gleichen Klasse holen? Wieso denn? Für den Fall dass die Get-Funktion mehr tun (könnte) als Kopien der Membervariablen zurückzugeben?



  • @titan99_ sagte in Klasse mit Methode, die mehrere Objekte der Klasse beinhaltet:

    Für den Fall dass die Get-Funktion mehr tun (könnte) als Kopien der Membervariablen zurückzugeben?

    Bingo!