Ich soll für eine template Klasse einen +operator überladen. Mein Compiler meckert aber und gibt
"expected constructor, destructor, or type conversion before âoperatorâ"
aus. Ich finde die Fehlermeldung an dieser Stelle etwas seltsam. Habt Ihr einen Tipp?

#include<iostream>

using namespace std;

template<typename T>class Complex{
	  private:
	  		  T re;
	  		  T im;

	  public:
	  		 Complex(T r=0,T i=0):re(r),im(i){}

        	 T get_re() const {return re;}
        	 T get_im() const {return im;}
        	 void set_re(T r) {re=r;}
        	 void set_im(T i) {im=i;}

	  };

template<typename T,typename S>class Kreis{
	  private:
	  		  Complex<T> mid;
	  		  S rad;

  	  public:
	  		 Kreis(Complex<T> m,double r):Complex<T>(m),rad(r){}
			   	Complex<T> get_mid() const {return mid;}
				S get_rad() const {return rad;}
				void set_mid(Complex<T>& m) {mid=m;}
				void set_rad(S r) {rad=r;}   	    
	  };	 

template<typename T>Complex operator-(const Complex<T>& z, const Complex<T>& w)
{
   Complex<T> r;
   r.get_re(z.get_re()+w.get_re());
   r.get_im(z.get_im()+w.get_im()); 
   return r;

}

int main()
{
return 0; 	
}

Lg Caro

Complex<T>

Und sag nächstes Mal bitte, in welcher Zeile der Fehler auftritt.

r.get_re(z.get_re()+w.get_re());
   r.get_im(z.get_im()+w.get_im());

Gibt ja wohl gar keinen Sinn. Meinst du r.set_re() ?

Die Fehlermeldung bezieht sich auf Zeile 33

Hab ich inzwischen gemerkt und sogar schon die Lösung hingeschrieben.

Complex<T> operator+(const Complex<T>& z, const Complex<T>& w)
{
   Complex<T> r;
   Complex<T>r.get_re(Complex<T>z.get_re()+Complex<T>w.get_re());
   Copmplex<T>r.get_im(Complex<T>z.get_im()+Complex<T>w.get_im()); 
   return Complex<T> r;

}

template<typename T>
Complex<T> operator+(const Complex<T>& z, const Complex<T>& w)
{
   Complex<T> r;
   r.set_re(z.get_re()+w.get_re());
   r.set_im(z.get_im()+w.get_im());
   return r;

}

return Complex<T>(z.get_re() + w.get_re(), z.get_im() + w.get_im());

Noch besser wäre es allerdings, einen operator+= anzubieten und den operator+ mithilfe dessen zu implementieren, so wie es in diesem Artikel erklärt wird. Lies den doch, dort stehen sehr viele wertvolle Informationen, was Operatorüberladung anbelangt.