Operator * für komplexe Zahlen für folgende Zeile : 3*c1*c2 redefinieren .

Bacid90210

Hey Leute ich hab da ein kleines Problemchen , wie bekomme ich es hin das mein Programm folge Zeile richtig interpretiert .

cout << “PRODUKT: “ << 3*c1*c2 << endl;

c1 und c2 sind Instanzen der Klasse complex mit

double re; 
double im;

Mein Ansatz ist folgender , allerdings erfolglos ...

complex& operator *(const complex& rhs)
	{   double re1;
		double im1;
		complex *Cc;
		re1 = this->re*rhs.re;
		im1 = this->im*rhs.im;
		Cc = new complex(re1,im1);
		return *Cc;
	}

	complex& operator *(const int& rhs)
	{
		double re1;
		double im1;
		complex *Cc;
		re1 = this->re*rhs;
		im1 = this->im*rhs;
		Cc = new complex(re1,im1);
		return *Cc;

	}

Bitte um Hilfe , bzw Tips , Lösungsansätze , bitte nicht den ganzen Lösungsweg aufschreiben ....

c1 und c2 sind Instanzen der Klasse complex mit

Meinst du std::complex? Bei std::complex sind diese Operatoren nämlich schon dabei.

Lies dir am besten auch das hier durch.

...

Bacid90210

Ja nein , der Sinn der Sache ist ja dies selber zu programmieren , also für unsere eigene Klasse complex .

Definier einfach einen globalen complex operator*(int, const complex&) .
Übrigens erzeugst du da ein schönes Memory-leak bei dir, weil du das zu returnende Objekt mit new anlegst. Böse.

#include <iostream>

struct complx
{
  double re, im;

  /// Dies hier ist auch ein "Konvertierungskonstruktor"
  /// da das explicit Schlüsselwort nicht auftaucht und
  /// der Konstruktor mit "einem Parameter aufrufbar" ist.
  complx(double r=0, double i=0) : re(r), im(i) {}
};

complx operator*(complx a, complx b)
{
  return complx(
    a.re*b.re-a.im*b.im,
    a.re*b.im+a.im*b.re
  );
}

int main() {
  complx a (2,3);
  complx b = 5 * a;
  complx c = a * 5;
  complx d = b*c;
  std::cout << b.re << ' ' << b.im << '\n';
  std::cout << c.re << ' ' << c.im << '\n';
  std::cout << d.re << ' ' << d.im << '\n';
}

Das funktioniert, weil
(1) operator* hier eine freie Funktion ist
(2) complx einen Konvertierungskonstruktor hat

Bei 5*a wird zunächst der int 5 automatisch zu complx konvertiert und dann der benutzerdefinierte operator* aufgerufen. Wenn Du operator* als Elementfunktion ("Methode") implementierst, muss auf der linken Seite schon ein complx-Objekt stehen, damit die Funktion aufgerufen werden kann.

Du kannst natürlich weitere operator* Funktionen anbieten, die direkt doubles verarbeiten können:

complx operator*(complx, double);
complx operator*(double, complx);

Damit könntest Du noch 2 Multiplikationen und 2 Additionen jeweils sparen. Aber notwendig ist das nicht, dank des Konvertierungskonstruktors.

Bacid90210

Wie implemetiere ich dies dann in den folgenden Code ???
Ich verstehe das irgenwie nicht ...

#include <iostream>
using namespace std;

class complex
{   

	private: 
	double re; 
	double im;

	public :
	complex(double real_part=0,double imag_part=0);

	friend ostream& operator <<(ostream& out,const complex& rhs) 
	{
		return out << rhs.re << " + " << rhs.im << 'i';    
	} 

	complex& operator + (const complex& rhs)
	{   double re1;
		double im1;
		complex *Cc;
		re1 = this->re + rhs.re;
		im1 = this->im + rhs.im;
		Cc = new complex(re1,im1);
		return *Cc;
	}

	complex& operator *(const complex& rhs)
	{   double re1;
		double im1;
		complex *Cc;
		re1 = this->re*rhs.re;
		im1 = this->im*rhs.im;
		Cc = new complex(re1,im1);
		return *Cc;
	}

};

Wie implemetiere ich dies dann in den folgenden Code ???

Lies doch einfach mal den Artikel über Operatorüberladung, den ich vorher verlinkt habe.

Da steht z.B., dass man z.B. die binäre Addition mit Hilfe der unären Addition (oder wie ist der deutsche Begriff für "compound") implementieren sollte.
D.h. du machst so etwas:

class complex
{
public:
  complex(const double real = 0, const double imag = 0): re(real), im(imag) { }

  complex& operator+=(const complex& rhs)
  {
    re += rhs.re;
    im += rhs.im;
    return *this;
  }

private:
  double re, im;
};

const complex operator+(const complex& lhs, const complex& rhs)
{
  complex temp(lhs);
  lhs += rhs; // Hier ist der "Trick", da man auf den vorher definierten operator+= zugreift
  return temp;
}

Habe den Code nicht getestet, aber der sollte so funktionieren.

...

Bacid90210 schrieb:

complex& operator + (const complex& rhs)
	{   double re1;
		double im1;
		complex *Cc;
		re1 = this->re + rhs.re;
		im1 = this->im + rhs.im;
		Cc = new complex(re1,im1);
		return *Cc;
	}

Tipp: operator+ nicht als Elementfunktion implementieren. Das mit dem new und & ist auch sehr unüblich. Man merkt Dir an, dass Du von einer anderen Sprache kommst, in der Objekte nur per new angelegt werden können. Hier ist das zu vermeiden. Das gleiche gilt für operator+. Implementiere die beiden als friend und lass das mit dem new/referenz blödsinn.