Ich hab eine Methode mit der ich zwar einen linken Klasseoperanden und einen anderen rechten Operanden vergleichen kann, aber ich würde es auch gerne andersrum haben. Ich wäre sehr dankbar, wenn mir jemand helfen könnte.
Folgenden Code hab ich bereits:

#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>
using namespace std;

class complex {
	double r, i;

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

		void print();
		complex conj();

		bool operator==(complex rightop);
		bool operator!=(complex rightop);

};

#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 complex::operator==(complex rightop){
	if (r==rightop.r && i == rightop.i) {
		return 1;
	}
	else return 0;
}

bool complex::operator!=(complex rightop) {
	if (r!=rightop.r && i!=rightop.i) {
		return 1;
	}
	else return 0;
}

Meinst du es so:

bool operator==(double, complex);
bool operator!=(double, complex);

bool complex::operator==(complex rightop){
	return (r==rightop.r && i == rightop.i);
}

bool complex::operator!=(complex rightop) {
	return (r!=rightop.r && i!=rightop.i);
}

Danke erstmals.

Meinst du es so:

bool operator==(double, complex);
bool operator!=(double, complex);

bool complex::operator==(complex rightop){
	return (r==rightop.r && i == rightop.i);
}

bool complex::operator!=(complex rightop) {
	return (r!=rightop.r && i!=rightop.i);
}

Mit diesen zwei Änderungen kommen folgende Fehler:

/tmp/cckDrML6.o: In Funktion `main':
complex1.C:(.text+0x1ea): Nicht definierter Verweis auf `operator==(double, complex)'
complex1.C:(.text+0x27d): Nicht definierter Verweis auf `operator!=(double, complex)'
collect2: error: ld returned 1 exit status

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

Sorry, bin aber noch ein Grünschnabel was die objektorientierte Programmierung angeht.

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

#include<iostream>
using namespace std;

class complex {
	double r, i;

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

		void print();
		complex conj();

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

#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==rh);

}

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

}

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.

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)

#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);

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

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.