Operandenproblem

Hier hast du mal ne klasse Endlosschleife:

bool operator==(complex const& lh, complex const& rh){
      return (lh==rh);
}

Du kannst den operator== nicht Implementieren indem dieser sich selbst aufruft. Du musst schon deinen Code von vorher nehmen der dann Real- und Imaginärteil vergleicht.

Pokerface

Ok, danke und wie kann ich nun auf den realen und imaginären Teil zugreifen?

Achso der private bei dir. Da gibts 3 Möglichkeiten die mir einfallen:

1. Du machst die Member public. Eigentlich nicht so schön aber bei komplexen Zahlen kann man dadurch das die Member public sind nichts kaputt machen.
2. Du erststellst Funktionen um den Real- und Imaginärteil auszulesen. Die sollte man so oder so haben, sonst ist deine Klasse wenig praktisch.
3. Du befreundest (siehe friend Keyword) die operator== Funktion (etwas unschöne Lösung)

Pokerface

Ich habs mal mit der public-Version probiert - hat funktioniert. Danke.
Da wir aber die Instanzvariablen private haben müssen, muss ich eine andere Variante auswählen.

Techel

Die friend-Version ist eigentlich gar nicht mal so unschön, schließlich gehört die Funktion ja direkt zur Klasse dazu.

Pokerface

Hab es so gelöst, passt das so?:

#include <iostream>
#include "complex.h"

using namespace std;

int main() {
  complex c1(2),c2(3,-4);
  double d1=2, d2(3);
  c2.print(); cout << " ist " << (c2==d2 ? "" : "nicht ") << "gleich ";
  cout << d2 << endl;
  c1.print(); cout << " ist " << (c1!=d1 ? "nicht " : "") << "gleich ";
  cout << d1 << endl;
  cout << d1 << " ist " << (d1==c1 ? "" : "nicht ") << "gleich ";
  c1.print(); cout << endl;
  cout << d2 << " ist " << (d2!=c2 ? "nicht " : "") << "gleich ";
  c2.print(); cout << endl;
  cout << "Die konjugiert komplexe Zahl zu "; c2.conj().print();
  cout << " ist "; c2.print(); cout << endl;
  return 0;
}

#include<iostream>
#include "complex.h"

using namespace std;

complex::complex() {
	r=0;
	i=0;
}

complex::complex (double a) {
	r=a;
	i=0;
}

complex::complex (double a, double b) {
	r=a;
	i=b;
}

void complex::print() {
	cout << r;
	if (i > 0) {
		cout << "+" << i << "i";
	}
	if (i < 0) {
		cout << i << "i";
	}
}

complex complex::conj() {
        return complex(r, -i);
}

bool operator==(complex const& lh, complex const& rh){
     return (lh.r==rh.r && lh.i == rh.i);
}

bool operator!=(complex const& lh,complex const& rh) {
     return !(lh.r==rh.r && lh.i == rh.i);
}

#include<iostream>
using namespace std;

class complex {
double r, i;

	public:
		complex();
		complex(double a);
		complex(double a, double b);

		void print();
		complex conj();

                friend bool operator==(complex const& lh,complex const& rh);
                friend bool operator!=(complex const& lh,complex const& rh);

};

bool operator==(complex const& lh,complex const& rh);
bool operator!=(complex const& lh,complex const& rh);

Ja. Allerdings wäre es wie schon gesagt praktisch trotzdem Funktionen zu haben mit der man den Real- und Imaginär auslesen kann.

PS: Den operator!= hättest du gar nicht ändern brauchen. Wenn du diesen implementierst indem du den operator== benutzt ist das schon OK.

Pokerface

Vielen, vielen Dank

Pokerface

SO, eine Frage hätte ich noch
Wie wichtig sind die const-Bezeichnungen?
Ist es ein Problem wenn ich sie einfach weglasse?

daddy_felix

Pokerface schrieb:

Wie wichtig sind die const-Bezeichnungen?
Ist es ein Problem wenn ich sie einfach weglasse?

das muss nicht unbedingt ein Problem sein, im günstigsten Fall ist es nur "schlechter Stil". Kann aber durchaus zu schwer zu findenden Bugs führen.

Daher solltest du verstehen, warum die const an den verschiedenen Stellen benötigt werden, und diese dementsprechend auch hinschreiben.