001-Folien: Los geht's: C++ um komplexe Zahlen erweitern

VL MRT-2
Algorithmen und
Datenstrukturen in C++
VL MRT-2, SS 2013
Professur für Prozessleittechnik

Übersicht
• Erste Schritte mit Eclipse/CDT
– Wie lege ich ein C++ Projekt an?
– Wie übersetze und starte ich ein Programm?
• Unser erstes C++ Programm
– Rechnen mit komplexen Zahlen
– Wie definiere ich eine neue Objektklasse?
– Wie definiere ich Attribute und Methoden?
– Wie nutze ich das nahtlos in meinem Programm?
08.04.2013 MRT2 (c) 2013, UR
Folie 2

Ziel: Frequenzgangs eines Filter berechnen
• Implementierung als C++-Programm?
double R = 1000, C = 1E-6, w;
complex c, j(0,1);
for (w=1; w

Los geht‘s: Hello World in C++
• Integrierte Entwicklungsumgebung
– Virtuelle Maschine mit der Applicance starten
– Eclipse/CDT starten
– ggf. neuen Workspace anlegen:
File Switch Workspace Other...
• C++ Projekt anlegen
– File New C++ Projekt
– Project Name: ComplexNumbers
Schriftart für die
Bedienung von
Eclipse-Menus
– ProjectType: Executable / Hello World C++ Projekt
08.04.2013 MRT2 (c) 2013, UR Folie 4

Eclipse/CDT IDE
Projektansicht
mit Verzeichnis
Editor
Konsolenausgabe
Schnellzugriff
für Ausführen,
Debuggen
Wechsel der
Perspektive
Struktur der
Datei im Editor
08.04.2013 MRT2 (c) 2013, UR Folie 5

ComplexNumbers.cpp – bekanntes von C
//====== [...]
#include
using namespace std;
int main() {
}
cout

Build & Run
• Build All (Strg+B)
– Übersetzt und bindet alle offenen Projektdateien
– Erzeugt lauffähige Programme
– Alternative: Project Build All
– Ausgabe in View Console (CDT Build Console)
• Run (Strg+F11)
– Startet das Programm des aktuellen Projekts
– Alterantive: Run Run As Local C/C++ Application
– Ausgabe in View Console (CDT Build Console)
08.04.2013 MRT2 (c) 2013, UR Folie 7

Zwei erste C++ Konzepte
//====== [...]
#include
using namespace std;
int main() {
}
cout

C++ Konzept Namensraum
• Problem C: Ein Name einer Methode kann nur einmal
verwendet werden Namenskonflikte
• Lösungsansatz C++: Strukturierung durch
hierarchische Namensräume - Meier aus Dresden
– Spezifikation eines Symbols aus einem Namensraums
durch Angabe des vollständigen Namen mit
Namensraumoperator :: namespace::methode
• Komfortfunktion
– Vorauswahl von Namensräumen
– using namespace namespace;
• Standard Bibliotheksfunktionen
– Namensraum std
08.04.2013 MRT2 (c) 2013, UR Folie 9

C++ Konzept Strom
• Ein Strom verarbeitet Sequenzen von
Zeichen
– Ein/Ausgabe auf Konsole: std::cout, std::cin
– Bidirektional (Datei, Zeichenkette)
• Ausgabeoperator

Komplexe Zahlen
• Definition
– c = a + b i; a,b und i²=-1
• Grundlegende Rechenoperationen
– c 1+c 2 = (a 1+a 2) + (b 1+b 2)i
– c 1-c 2 = (a 1-a 2) + (b 1-b 2)i
– c 1*c 2 = (a 1a 2-b 1b 2) + (a 1b 2+b 1a 2)i
– c 1/c 2 = (a 1a 2+b 1b 2)/(a 2²+ b 2²)+((a 1b 2-b 1a 2)
/(a 2²+ b 2²))i
08.04.2013 MRT2 (c) 2013, UR Folie 11

Abbildung in eine C++ Klasse
• Abstrakter Datentyp mit Attributen a,b
• Operatoren +, -, *, /
• Auswahl Real und Imaginärteil
• Ausgabeoperator

Anlegen einer neuen Klasse
• Im Kontextmenu des Projektbaums new class
– Class name: complex
– Kein Destruktor
– Es werden zwei Dateien erzeugt
• Header complex.h
– Deklaration der Klasse
– Methoden
– Attribute
• Implementierung complex.cpp
– Implementierung der Algorithmen
08.04.2013 MRT2 (c) 2013, UR Folie 13

complex.h - Gerüst
class complex {
public:
};
complex();
C++ Konzept:
Klasse
C++ Konzept:
Zugriffsmoderator
C++ Konzept:
Konstruktor
08.04.2013 MRT2 (c) 2013, UR Folie 14

Attribute, Zugriffsmethoden und
Konstruktoren
• Private Attribute
– double real;
– double imag;
• Öffentliche Zugriffsmethoden
– double Re();
– double Im();
• Öffentlicher Konstruktor mit Defaultwerten
– complex(double r = 0.0, double i = 0.0);
08.04.2013 MRT2 (c) 2013, UR Folie 15

Deklaration in
Complex.h
class complex {
private:
double real;
double imag;
public:
};
// Konstruktoren
complex(double r = 0.0, double i = 0.0);
// Zugriff auf die Attribute
double Re();
double Im();
Zugriffsmoderator
gilt bis zum
nächsten. Default ist
protected
Parameter mit
default-werten sind
optional.
Einschränkung:
kein Default in der
Mitte, nur vom
rechten Ende her!
08.04.2013 MRT2 (c) 2013, UR Folie 16

Implementierung in
Complex.cpp
#include "complex.h"
complex::complex(double r, double i) :
}
real(r), imag(i) {
double complex::Re() {
}
return real;
double complex::Im() {
}
return imag;
Import der
Prototypen
Zuordnung zum
Namensraum der
Klasse Complex
Elementinitialisierungsliste
mit Kopier-
Konstruktoren
08.04.2013 MRT2 (c) 2013, UR Folie 17

Anwendung
int main() {
}
complex c0(1,2), c1, c2(c0);
cout

Ausgabe von Klassen auf Strom
• Wie sieht eine Methode aus, die das gleiche
Ergebnis liefert, aber eleganter in der
Anwendung ist: cout

C++ Konzept: operator
• Häufig Ausdrucksmuster der Art:
– Ergebnis = LinkerOperand Operator
RechterOperand;
– Arithmetik, Logik, ...
• Lösungsansatz in C oder Java:
– Ergebnis = Methode(Operand1, Operand2)
– Methodennamen beginnen mit [_A-Za-z]
• C++: Überschreiben von Operatoren
– Ergebnis = operatorXX(Operand1, Operand2)
– XX ist das symbolische Kürzel des Operators
08.04.2013 MRT2 (c) 2013, UR Folie 20

complex.h - Entwurf operator

Ziel: Frequenzgang eines Filters berechnen
double R, C, w;
complex c, j;
c = ( R / R + 1 / ( j * w * C ) );
• Definition
– a,b,d ; i²=-1; c = a + b i;
• Arithmetik
– c 1+c 2 = (a 1+a 2) + (b 1+b 2)i
– c 1-c 2 = (a 1-a 2) + (b 1-b 2)i
– c 1*c 2 = (a 1a 2-b 1b 2) + (a 1b 2+b 1a 2)i
– c 1/c 2 = (a 1a 2+b 1b 2)/(a 2²+ b 2²)+((a 1b 2-b 1a 2) /(a 2²+
b 2²))i
double / complex
complex * double
08.04.2013 MRT2 (c) 2013, UR Folie 22

Ausflug: Überladen von Operatoren in C++
• Fast alle Operatoren sind überladbar:
• Nicht überladen werden können
:: .* . ?:
• Es gibt keine neuen Operatoren
08.04.2013 MRT2 (c) 2013, UR Folie 23

Regeln (1/2)
• Ein überladener Operator muss mindestens
einen Operanden vom Typ Klasse besitzen
• Priorität, Assoziativität und Anzahl der
Operanden eines Operators können nicht
verändert werden
– Beispiel: A == B + C;
– Resultiert, unabhängig vom Typ von A,B,C und
den ggf. überladenen Operatoren immer in:
operator==(A, operator+(B, C));
08.04.2013 MRT2 (c) 2013, UR Folie 24

Regeln (2/2)
• Kurzschlusseigenschaft von logischem und
(&&), logischem oder (||) bleiben nicht
erhalten
– Es werden immer beide Operanden ausgewertet
– Reihenfolge der Auswertung ist nicht festgelegt
• Reihenfolge der Auswertung für
Kommaoperator ist nicht definiert
08.04.2013 MRT2 (c) 2013, UR Folie 25

Operator als Elementfunktion einer Klasse
• Überladene Operatoren dürfen sowohl als
herkömmliche Nichtelementfunktion als auch
als Elementfunktion definiert werden.
• Beispiel: Binärer Operator += : c += j
• Definition als Nichtelementfunktion:
complex& operator+=(const complex& lhs,
const complex& rhs)
• Definition als Elementfunktion:
complex& complex::operator+=(const complex&
rhs)
08.04.2013 MRT2 (c) 2013, UR Folie 26

Elementfunktion vs Nichtelementfunktion
• Definition als Nichtelementfunktion:
complex& operator+=(const complex& lhs,
const complex& rhs)
• Definition als Elementfunktion:
complex& complex::operator+=(const complex&
rhs)
• Achtung: Bei einer Definition als
Elementfunktion ist der erste Operand das
Objekt, repräsentiert durch den impliziten
Zeiger this.
08.04.2013 MRT2 (c) 2013, UR Folie 27

Der implizite Zeiger this
• Jede Elementfunktion hat einen impliziten
Parameter: this
• this ist ein Zeiger auf ein Objekt des
Klassentyps.
• this ist an das Objekt gebunden, für das die
Elementfunktion aufgerufen wurde.
• this wird immer dann benötigt, wenn wir uns
auf das Objekt als Ganzes beziehen wollen.
08.04.2013 MRT2 (c) 2013, UR Folie 28

Beispiel complex
• Per Definition muss += eine Referenz (= ein
Stellvertreter, gekennzeichnet durch das &)
auf das Objekt zurückgeben
// complex += complex
complex& complex::operator+=(const
complex& rhs) {
real+=rhs.real; imag+=rhs.imag;
return *this;
}
08.04.2013 MRT2 (c) 2013, UR Folie 29

Heuristiken für Operatorüberladung (1/4)
• Der Compiler überlädt automatisch:
– Zuweisungsoperator (=): Elementweise Zuweisung
– Addressierungs- (&) und Kommaoperator (,)
• Arithmetische Operatoren (+, -, *, /, …)
– gemäß Häufigkeit und eindeutiger
Interpretierbarkeit
• Zuweisungsoperatoren (+=, -=, …)
– Günstig, wenn entsprechender arithmetischer
Operator definiert ist
08.04.2013 MRT2 (c) 2013, UR Folie 30

Heuristiken zur Operatorüberladung (2/4)
• Gleichheits- und relationale Operatoren
– Wenn Schlüssel in assoziativem Container, dann
mindestens <
– Wenn Eintrag in sequentiellem Container, dann <
und == für Algorithmen wie find (==) und sort
(,>= und

Elementfkt vs. Nichtelementfkt.
• Elementfunktionen müssen sein:
– Zuweisung (=), Indizierung ([]), Aufruf (()) und
Elementzugriffspfeil (->)
• Elementfunktion sollten sein:
– Operatoren die den Zustand ihres Objekts verändern
oder damit eng verknüpft sind
– Zuweisungsoperatoren ( += -= ), Inkrementierung
(++), Dekrementierung (--), Dereferenzierung (*)
• Nichtelementfunktionen sollten sein:
– Symetrische Operatoren wie Arithmetik (+ - * /)
Gleichheit (==), relationale (< > =) und bitweise
(& | ^) Operatoren
08.04.2013 MRT2 (c) 2013, UR Folie 32

Rechenoperationen
• Ziel: Frequenzgang eines Filters berechnen
double R, C, w;
complex c, j;
c = ( R / R + 1 / ( j * w * C ) );
• Definition
– a,b,d und i²=-1
– c = a + b i;
• Arithmetik
– c 1+c 2 = (a 1+a 2) + (b 1+b 2)i, c 1-c 2 = (a 1-a 2) + (b 1-b 2)i
– c 1*c 2 = (a 1a 2-b 1b 2) + (a 1b 2+b 1a 2)i
– c 1/c 2 = (a 1a 2+b 1b 2)/(a 2²+ b 2²)+((a 1b 2-b 1a 2) /(a 2²+
b 2²))i
08.04.2013 MRT2 (c) 2013, UR Folie 33

complex + complex
• Elementfunktion operator+=
// complex += complex
complex& complex::operator+=(const complex& rhs) {
real+=rhs.real; imag+=rhs.imag;
return *this; }
• Nichtelementfunktion operator+
// complex = complex + complex
inline complex operator+(const complex& lhs, const
complex& rhs) {
}
complex cret(lhs);
return cret += rhs;
08.04.2013 MRT2 (c) 2013, UR Folie 34

Selbstständig vervollständigen...
(kontrolliertes copy , paste & modify)
• EF: operator+=(const double)
• NEF: operator+ (const double, const
complex&)
• Analog für -, * und /
08.04.2013 MRT2 (c) 2013, UR Folie 35

Testen
int main() {
complex c(2,1);
cout

Berechnung Transferfunktion
complex j(0,1);
double C(1e-6), R(1000);
complex transfer_function(double w) {
}
return R / ( R + 1 / ( j * w * C ));
int main() {
}
for (double w=1; w < 1000; w += 3 ) {
complex r = transfer_function(w);
cout

Anzeigen mit gnuplot
• Starten des Programms von der Konsole und
Umleiten der Ausgabe in eine Datei:
– cd MRT2/ComplexNumbers/Debug
– ./ComplexNumbers > q.q
• Anzeigen der 3ten über
der 2ten Spalte
– gnuplot
– plot 'q.q' using 2:3 with lines
– exit
08.04.2013 MRT2 (c) 2013, UR Folie 38