/*
 * Programmieren fuer Physiker, SS 2010
 *
 * Beispiel fuer eine Klasse und Methoden
 * hier: komplexe Zahlen und einige Operationen damit
 */

#include <iostream>
#include <cmath>

using namespace std ;

// ------ Klasse comp und Mitgliederfunktionen

class comp
{
private:        // von "aussen" i.A. unzugaengliche Komponenten
    double re ;
    double im ;
public:         // oeffentliche zugreifbare Komponenten
    comp(double a=0.0, double b=0.0)  // Konstruktor. Per default Komponenten null
	{ re=a ; im=b ; } ;
    void setze(double, double) ;  // Deklaration einer Mitgliedsfunktion
    void print()  // hier als Beispiel kompletter Funktionskoerper
	{ 
	    cout << "(Re,Im)=" << re << " " << im << endl  ;
	} 
    comp operator+ (comp) ;  // addiere zwei komplexe Zahlen 
    comp operator- (comp) ;  // subtrahiere zwei komplexe Zahlen 
    comp operator- () ;      // Minus als Vorzeichen (unaer)
    comp operator* (comp) ;  // multipliziere zwei kompl. Zahlen
    // weitere sinnvolle Rechenoperationen bitte selbst programmieren...
    bool operator== (comp) ; // auch Vergleichsoperatoren moeglich!
    friend double abs(comp) ;
    friend ostream & operator<< (ostream &, comp) ;
} ;

void comp::setze (double x, double y)
{
    re=x ;
    im=y ;
    return ;  // nicht noetig ohne Wert am Ende einer Funktion
}

comp comp::operator+ (comp op2)
{
    comp c ;
    c.re = re + op2.re ;
    c.im = im + op2.im ;
    return c ;
}

comp comp::operator- (comp op2)
{
    comp c ;
    c.re = re - op2.re ;
    c.im = im - op2.im ;
    return c ;
}

comp comp::operator- ()
{
    comp c ;       // nicht die eigene Instanz aendern, 
    c.re = -re ;   // sondern Objekt mit negativem Wert zurueckgeben!
    c.im = -im ;
    return c ;
}

comp comp::operator* (comp op2)
{
    comp c ;
    c.re = re*op2.re - im*op2.im ;
    c.im = re*op2.im + im*op2.re ;
    return c ;
}

bool comp::operator== (comp op2)
{
    if (re==op2.re && im==op2.im) return true ;
    return false ;
}

// ------ Freunde von Klasse comp

double abs(comp z)
{
    double l=sqrt(z.re*z.re+z.im*z.im) ;
    return l ;
}

ostream & operator<< (ostream & str, comp z) 
{
    str << "(Re,Im)=" << z.re << " " << z.im  ;
    return str ;
}

// ------ main

int main()
{
    comp r ;
    r.setze(0.0,1.0) ;
    comp s ;

    // s.im = 7.0 // nicht erlaubter Zugriff auf Klassenmitglied
    s = r ;      // ok, elementweises kopieren 
    s.print() ;  // wende Methode "print()" auf das Objekt s an

    s = r.operator*(r) ; // lange Form fuer s=r*r
    s = r*r ;            // ... oder kurz und griffig
    cout << "Eine kleine Rechnung: " << r+s 
	 << "  und das hat den Betrag " << abs(r+s) << endl ;

    s = -r ; // Minus als Vorzeichen (kurz fuer r.operator-())
}