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.

...

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.

#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.

...

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.