in dem Programm ist der +-Operator überladen, um komplexe Zahlen zu addieren.

class Komplex{

double Re;
double Im;

public:

/*
...
*/

// Ueberladung der Addition

Komplex operator+(const Komplex &z )const{
	Komplex sum;
	sum.Re = this -> Re + z.Re; // Zugriff auf Re-Member vom Objekt sum
	sum.Im = this -> Im + z.Im; // do.

	return sum;
	}

};

Der Code funktioniert wie gewünscht, doch folgendes verstehe ich nicht,

wieso kann man auf sum.Re zugreifen, Re ist doch als private deklariert?

Ich habe mit C++ und Programmieren noch nicht so viel Erfahrung und bin darum für Antworten sehr dankbar.

Vielen Dank schon jetzt

Aiko

class Komplex{
private: // habe ich hinzu gefügt
double Re;
double Im;

public:

meines er achtens müsste da noch ein privat über dem double Re.

aber das von ihm hört sich logischer an

gruß
coco

das ging ja schnell.

firefly schrieb:

bei dir ist die Implementierung des "+ Operators" ein Member der Klasse und somit kann diese auch auf private Member zugreifen.

... natürlich jetzt wo du's sagst.

Vielen Dank für die Antworten

Aiko

meines er achtens müsste da noch ein privat über dem double Re.
coco

Das default scoping von einer class in C++ ist private.
Das default scoping eines structs in C++ ist public.

Bei class ist alles, sofern nichts anderes explizit angegeben, private.

Aiko schrieb:

class Komplex
{
  double Re;
  double Im;
public:

  /*
  ...
  */

  // Ueberladung der Addition

  Komplex operator+(const Komplex &z ) const
  {
	Komplex sum;
	sum.Re = this -> Re + z.Re; // Zugriff auf Re-Member vom Objekt sum
	sum.Im = this -> Im + z.Im; // do.
	
	return sum;
  }

};

...ist das nicht der Weisheit letzter Schluss bzgl Implementierung eines eigenen Komplex-Typs. Erst mal frage ich mich, wie sinnvoll es ist, Re und Im private zu machen. Eine komplexe Zahl besteht nun mal aus Real- und Imaginärteil. Das ist kein "Implementierungsdetail", dass man vor Zugriff schützen müsste, um irgendwelche Invarianten einzuhalten. Dann ist auch bekannt, dass operator+ in so einer Situation als freie Funktion gewisse Vorteile bietet. Zum Beispiel erlaubt mir folgendes

struct komplex
{
  double re, im;

  komplex(double r=0, double i=0)
  : re(r), im(i)
  {}
};

inline komplex operator+(komplex const& a, komplex const& b)
{
  return {a.re+b.re, a.im+b.im};
}

dann folgende Operationen:

int main()
{
  komplex z {2,3};
  auto a = z + z;
  auto b = z + 3.14;
  auto c = 2.718 + z;
}

da sogar die 2.718 durch den impliziten Konstruktor von komplex zu einem komplex-Objekt wird und anschließend operator+(komplex,komplex) aufgerufen werden kann. Das klappt mit operator+ als Elementfunktion nicht, da die linke Seite da schon ein komplex-Objekt sein müsste.