Beispiel einer Klasse für komplexe Zahlen

Im Rahmen der Vorlesung wurde zum Thema C++ als einführendes Beispiel eine Klasse zum Arbeiten mit komplexen Zahlen erstellt und über einige Wochen hinweg erweitert. Das Ergebnis ist auf dieser Seite wiedergegeben. Das Programm wurde auf zwei Quellcode-Dateien verteilt, die über eine Header-Datei 'verbunden' sind.


Die Headerdatei complex.h

// =========================================================
// Dateiname: complex.h
// Autor: Robert Heß und E2a
// Version: 1.01
// Datum: 3.12.2009
// Beschreibung: Eine Klasse für komplexe Zahlen
// =========================================================

// Sicherstellen, dass diese Klasse nur einmal pro
// Quellcodedatei deklariert wird
#ifndef CLASS_COMPLEX_BY_E2A_INCLUDED
#define CLASS_COMPLEX_BY_E2A_INCLUDED

// Eine Klasse für komplexe Zahlen
class complex {
private:
    // keine privaten Elemente
protected:
    // keine geschützten Elemente
public:
    // Attribute
    double re;
    double im;

    // Methoden
    complex();
    complex(double r, double i);
    ~complex();
    double abs();
    double phi();
    complex operator+(complex b);
    complex operator+(double b);
    complex operator-(complex b);
    complex operator-(double b);
    complex operator*(complex b);
    complex operator*(double b);
    complex operator/(complex b);
    complex operator/(double b);
};

// Operatoren, die als linken Operanden keine Klasse haben,
// können nur außerhalb der Klasse implementiert werden:
complex operator+(double a, complex b);
complex operator-(double a, complex b);
complex operator*(double a, complex b);
complex operator/(double a, complex b);

#endif // #ifndef CLASS_COMPLEX_BY_E2A_INCLUDED

Die Quellcodedatei complex.cpp

// =========================================================
// Dateiname: complex.cpp
// Autor: Robert Heß und E2a
// Version: 1.01
// Datum: 3.12.2009
// Beschreibung: Eine Klasse für komplexe Zahlen
// =========================================================

#include "complex.h"
#include <cmath>

// Standard-Konstruktor
complex::complex()
{
    re = 0;
    im = 0;
}

// Konstruktor zum Setzen der komplexen Zahl
complex::complex(double r, double i)
{
    re = r;
    im = i;
}

// Destruktor
complex::~complex()
{
    // leer
}

// Betrag der komplexen Zahl
double complex::abs()
{
    return sqrt(re*re+im*im);
}

// Winkel der komplexen Zahl in Polar-Koordinaten
// relativ zur X-Achse
double complex::phi()
{
    return atan2(im, re);
}

// Addition von zwei komplexen Zahlen
complex complex::operator+(complex b)
{
    complex s;

    s.re = re+b.re;
    s.im = im+b.im;

    return s;
}

// Addition einer komplexen und einer reellen Zahl
complex complex::operator+(double b)
{
    complex s;

    s.re = re+b;
    s.im = im;

    return s;
}

// Addition einer reellen und einer komplexen Zahl
complex operator+(double a, complex b)
{
    complex s;

    s.re = a+b.re;
    s.im = b.im;

    return s;
}

// Subtraktion von zwei komplexen Zahlen
complex complex::operator-(complex b)
{
    complex s;

    s.re = re-b.re;
    s.im = im-b.im;

    return s;
}

// Subtraktion einer komplexen und einer reellen Zahl
complex complex::operator-(double b)
{
    complex s;

    s.re = re-b;
    s.im = im;

    return s;
}

// Subtraktion einer reellen und einer komplexen Zahl
complex operator-(double a, complex b)
{
    complex s;

    s.re = a-b.re;
    s.im = -b.im;

    return s;
}

// Multiplikation von zwei komplexen Zahlen
complex complex::operator*(complex b)
{
    complex s;

    s.re = re*b.re-im*b.im;
    s.im = re*b.im+b.re*im;

    return s;
}

// Multiplikation einer komplexen und einer reellen Zahl
complex complex::operator*(double b)
{
    complex s;

    s.re = re*b;
    s.im = im*b;

    return s;
}

// Multiplikation einer reellen und einer komplexen Zahl
complex operator*(double a, complex b)
{
    complex s;

    s.re = a*b.re;
    s.im = a*b.im;

    return s;
}

// Division von zwei komplexen Zahlen
complex complex::operator/(complex b)
{
    complex s;
    double Nenner;

    Nenner = b.re*b.re+b.im*b.im;
    s.re = (re*b.re+im*b.im)/Nenner;
    s.im = (im*b.re-re*b.im)/Nenner;

    return s;
}

// Division einer komplexen und einer reellen Zahl
complex complex::operator/(double b)
{
    complex s;

    s.re = re/b;
    s.im = im/b;

    return s;
}

// Division einer reellen und einer komplexen Zahl
complex operator/(double a, complex b)
{
    complex s;
    double Nenner;

    Nenner = b.re*b.re+b.im*b.im;
    s.re = a*b.re/Nenner;
    s.im = -a*b.im/Nenner;

    return s;
}

Die Quellcodedatei main.cpp

// =========================================================
// Dateiname: main.cpp
// Autor: Robert Heß und E2a
// Version: 1.01
// Datum: 3.12.2009
// Beschreibung: Verwendung von Komplexen Zahlen am Beispiel
//               eines seriellen Schwingkreises
// =========================================================

#include "complex.h"
#include <cmath>
#include <iostream>
#include <iomanip>
using namespace std;

const double pi=3.141592653589793;

int main()
{
    // Verwendung von Komplexen Zahlen am Beispiel
    // eines seriellen Schwingkreises
    double R=100;       // Widerstand
    double C=1.8e-6;    // Kapazität
    double L=0.015;     // Induktivität
    double f;           // aktuelle Frequenz
    double w=2*pi*1000; // aktuelle Kreisfrequenz
    complex i(0, 1);    // imaginärer Einheitswert: sqrt(-1)
    complex c;          // komplexes Ergebnis
    int j;              // lokale Laufvariable
    int Anzahl=20;      // Anzahl der Frequenzschritte

    // Überschriften ausgeben
    cout << "Frequenzgang eines seriellen Schwingkreises" << endl;
    cout << "R: " << R << endl;
    cout << "C: " << C << endl;
    cout << "L: " << L << endl;
    cout << "  Frequenz    Realteil Imagin\204rteil  Amplitude       Phase" << endl;
    cout << "      (Hz)         (-)         (-)         (-)       (deg)" << endl;


    // Schleife über alle Frequenzen
    for(j=0; j<=Anzahl; j++) {
        // Berechnung der Frequenz und Kreisfrequenz
        f = 100*exp(j*log(100)/Anzahl);
        w = 2*pi*f;

        // Berechnung des Schwingkreises
        c = R/(i*w*L+1/(i*w*C)+R);

        // Ausgabe der Ergebnisse
        cout << setw(10) << f << "  ";
        cout << setw(10) << c.re << "  ";
        cout << setw(10) << c.im << "  ";
        cout << setw(10) << c.abs() << "  ";
        cout << setw(10) << c.phi() << endl;
    }

    return 0;
}

Seite 20