Verständnisprobleme Operator/Kopierkonstruktor



  • Guten Abend die Herren/Damen 🙂 ,

    leider habe ich mit folgendem Programm so meine Schwierigkeiten.

    Die Aufgabe behandelt einen Klassen-/Funktionsaufbau zum berechnen eines Ortsvektors.

    Folgendes Programmskelett ist gegeben : (habe versucht möglichst mit kommentaren meine schwierigkeiten zu verdeutlichen)

    #include <iostream>
    #include <cmath>
    
    using namespace std;
    
    class Punkt 
    {
    public :
    	Punkt (double,double,double);						// Konstruktor für x,y,z.
    	friend void anzeigen(ostream os, const Punkt&);		// Friendfunktion für x,y,z
    	double betrag();									// Länge des Ortsvektors (Betrag)
    	Punkt& Punkt::operator+=(const Punkt& b);			// Zuweisungsoperator
    // rückgabewert des operators ist das objekt dem etwas zugewiesen wird.
    // das ein neues objekt erzeugt wird reicht eine referenz als rückgabewert. b = referenz auf punkt
    private :
    	double x,y,z;										//Koordinaten
    };
    
    Punkt::Punkt(double xx,double yy,double zz): xx(0),yy(0),zz(0)
    {
    x=xx;
    y=yy;
    z=zz;
    }; // habe ich die Initialisierungsliste korrekt ausgeführt ?
    
    double Punkt::betrag() // zum berechnen von b=sqrt(x²+y²+z²)
    {
    	betrag=sqrt((xx*xx)+(yy*yy)+(zz*zz)); // möglich ???
    
    }
    
    Punkt& Punkt::operator+=(const Punkt& b)
    {
    	// wie verfahre ich mit dem operator ? , muss ich zusätzlich einen kopierkonstruktor aufrufen ? wenn ja , was übergebe ich und wie ?
    }
    
    void anzeigen( ???? ) // wie verwende ich die Friends funktion , inwiefern benötige ich sie ? wieso zugriff direkt auf x etc. und nicht auf alias ?
    {
    	return ????
    }
    
    int main()
    {
    	Punkt P1(3,4,0);			// Objekt P1 vom Typ Punkt mit eigenschaften
    	Punkt P2(0,0,3);			//  x=0, y=0 , z=3 ;
    	cout << P1.betrag() << endl; // Eigenschaft betrag von Punkt 1
    	anzeigen(cout, P1);
    	P1+=P2;
    	anzeigen(cout, P1);
    }
    

    Vielleicht habt ihr ja den ein oder anderen tip 🕶

    Danke

    Peter



  • double Punkt::betrag() // zum berechnen von b=sqrt(x²+y²+z²)
    {
        return sqrt((xx*xx)+(yy*yy)+(zz*zz)); // betrag wurde nie definiert, also würde Fehler bringen
    
    }
    
    Punkt& Punkt::operator+=(const Punkt& b)
    {
        // wie verfahre ich mit dem operator ? , muss ich zusätzlich e
    inen kopierkonstruktor aufrufen ? wenn ja , was übergebe ich und wie ?
        this.x = this.x + b.x;
        this.y = this.y + b.y;
        this.z = this.z + b.z;
    
        retun (*this);
    }
    

    sollte so in der art gehen, nur hab ich es net getestet



  • #include <iostream>
    #include <cmath>
    
    using namespace std;
    
    class Punkt 
    {
    public :
      Punkt (double xx, double yy, double zz);	
      //Punkt (double,double,double);
    
      friend void anzeigen(ostream os, const Punkt& p);
      //friend void anzeigen(ostream os, const Punkt&);
    
      double betrag();
    
      //das ist keine Zuweisung sondern Addieren und Punkt:: hat hier nichts zu suchen				
      Punkt& operator+=(const Punkt& b);
    
    private :
    	double x,y,z;
    };
    
    Punkt::Punkt(double xx,double yy,double zz)
      :x(xx),y(yy),z(zz)  //die Member-Variablen x,y,z werden gesetzt, deswegen kann man x=xx;  x=xx; z=zz weglassen
    {
    }
    
    double Punkt::betrag()
    {
      return sqrt((x*x)+(y*y)+(z*z));
      //du kannst betrag nichts zuweisen, da eine funktion
      //durch return ... gibt man den Rückgabewert der Funktion an
      //und xx, yy, zz kannst du hier nicht verwenden, hier gibt es nur die
      //Member der Klasse (x,y,z)
    }
    
    Punkt& Punkt::operator+=(const Punkt& b)
    {
       //durch diesen Operator kannst du später folgendes machen:
       //Punkt a;
       //Punkt b;
       //a += b;  //a ist danach a + b, geht auch so "a = a + b;"
    
       x += b.x;
       y += b.y;
       z += b.z;
       return *this;
    }
    
    Friend-Funktionen sind keine Methoden der Klassen und bekommen keinen Zeiger auf das jeweilige Objekt übergeben, werden wie normale Funktionen deklariert, also ohne Punkt::...
    Ergibt aber hier keinen Sinn, würde es so mahcnen: P1.ausgeben(ostream os) 
    void anzeigen(ostream os, const Punkt& p)
    {
       //tja hier gibts du wohl den Punkt als Stream aus
    }
    
    int main()
    {
    	Punkt P1(3,4,0);			// Objekt P1 vom Typ Punkt mit eigenschaften
    	Punkt P2(0,0,3);			//  x=0, y=0 , z=3 ;
    	cout << P1.betrag() << endl; // Eigenschaft betrag von Punkt 1
    	anzeigen(cout, P1);
    	P1+=P2;
    	anzeigen(cout, P1);
    }
    


  • vielen dank ,eure antworten helfen mir schonmal sehr weiter 🙂

    werde mich morgen früh weiter damit beschäftigen.

    gute nacht 👍

    peter



  • Dieser Thread wurde von Moderator/in Martin Richter aus dem Forum MFC (Visual C++) in das Forum C++ (auch C++0x und C++11) verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.


Log in to reply