Programmieren in C / C++ Klassen und Vererbung, Templates Hochschule Fulda – FB AI Sommersemester 2017 http://c.rz.hs-fulda.de Peter Klingebiel, HS Fulda, FB AI

C++ 1 wichtiges Paradigma  Objektorientierung Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

C++ 2 Klassen / Objekte kapseln  Daten (= Membervariable, Attribute)  Operationen (= Memberfunktionen, Methoden) Membervariable in C++-Klassen = Daten in C Memberfunktionen in C++-Klassen = Funktionen in C Objekte enstehen durch Instantiierung einer Klasse Objekt erhält Speicherplatz zugewiesen Attribute werden initialisiert Methoden werden aufrufbar Trennung von Deklaration und Implementierung Deklaration  Headerdatei class.h Implementierung  Quelldatei class.cpp Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Beispielklasse Arduino-Pins 1 // klassendeklaration Pin.h #ifndef _PIN_H #define _PIN_H // datentypen fuer pin mode und pin value enum PinMode { input = 0, output = 1, nomode = -1 }; enum PinValue { low = 0, high = 1, novalue = -1 }; // klasse Pin class Pin { public: // oeffentlich zugreifbar // konstrukturen und destruktoren Pin(int, PinMode); ~Pin(void); Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Beispielklasse Arduino-Pins 2 // weitere zugriffsmethoden void setPin(int); int getPin(void); void setMode(PinMode); PinMode getMode(void); // lese- und schreibfunktionen void write(PinValue); PinValue read(void); PinValue getValue(void); // interner zaehler int getCounter(void); static void setCounter(int); Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Beispielklasse Arduino-Pins 3 // attribute protected: // oeffentlich nicht zugreifbar, aber // zugreifbar fuer abgeleitete klassen int pin_; // pin nummer PinMode mode_; // mode: input oder output PinValue value_; // value: low oder high // interner zaehler static int intcnt_; // klassenzaehler int counter_; // objektzaehler }; #endif // _PIN_H Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Beispielklasse Arduino-Pins 4 // klassenimplementierung Pin.cpp #include "Pin.h" Pin::Pin(int p, PinMode m) // konstruktor { pin_ = p; mode_ = m; value_ = novalue; ++intcnt_; counter_ = intcnt_; pinMode(pin_, mode_); } Pin::~Pin(void) { } // destruktor: nix zu tun Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Beispielklasse Arduino-Pins 5 // zugriffsmethoden void Pin::setPin(int p) { pin_ = p; } int Pin::getPin(void) { return pin_; void Pin::setMode(PinMode m) { mode_ = m; // pinMode(pin_, mode_); PinMode Pin::getMode(void) { return mode_; Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Beispielklasse Arduino-Pins 6 // schreib- und lesefunktionen void Pin::write(PinValue v) { if(mode_ == input) { // fehler: meldung / exception return; } value_ = v; digitalWrite(pin_, value_); PinValue Pin::read(void) { if(mode_ == output) { return novalue; value_ = PinValue(digitalRead(pin_)); return value_; Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Beispielklasse Arduino-Pins 7 // weitere schreib- und lesefunktionen PinValue Pin::getValue(void) { return value_; } // zugriffsfunktionen fuer internen klassenzaehler int Pin::getCounter(void) { return counter_; void Pin::setCounter(int c) { intcnt_ = c; int Pin::intcnt_ = 0; Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Beispielklasse Arduino-Pins 8 // pins.ino – led blinken #include "Pin.h" Pin led = Pin(8, output); // instantiierung void setup() { // nix zu tun } void loop() { led.write(high); // led an delay(500); led.write(low); // led aus } Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Statische Membervariable 1 normale Attribute werden objektbezogen, d.h. einmal je Objekt angelegt gelegentlich notwendig: statische Attribute statische Attribute werden nur einmal je Klasse angelegt und sind für alle Objekte einer Klasse zugreifbar und nutzbar class Demo { private: int cnt_; // objektbezogen static icnt_; // klassenbezogen public: Demo(void); // konstruktor int getCnt(); // zaehler liefern ... Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Statische Membervariable 2 statische Attribute können nicht direkt zugegriffen werden  in Membervariablen zugreifbar machen Konstruktor Demo::Demo(void) { icnt_++; // zaehler hochzaehlen cnt_ = icnt_; // in attribut merken } int Demo::getCnt() { return cnt_; } int Demo::icnt: = 0; // zaehler initialisieren Objekte erzeugen und Zähler ausgeben Demo demo1 = Demo(); // 1. Objekt -> icnt_: 1 Demo demo2 = Demo(); // 2. Objekt -> icnt_: 2 cout << demo1.getCnt(); // -> 1 cout << demo2.getCnt(); // -> 2 Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Statische Memberfunktionen 1 auch Methoden können statisch sein und damit einmal für die ganze Klasse existieren Erweiterung der Klassen Demo class Demo { private: static int icnt_; // zaehler public: static void setCnt(int); // zaehler setzen } void Demo::setCnt(int c) { icnt_ = c; } Aufruf der statischen Funktion Demo::setCnt(4711); Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Befreundete Funktionen 1 Ziel der OOP: Daten kapseln  Daten verbergen und Zugriff nur über Memberfunktionen, um die Fehleranfälligkeit von Programmen zu verringern manchmal ist es vorteilhaft, diesen Schutz gezielt zu umgehen, da dies ggfs. effizienter, wenn auch unsicherer ist mittels friend-Funktionen kann ein Objekt auf Daten zugreifen, die nicht zum eigenen, sondern einem anderen Objekt gehören Der Umgang mit friend-Funktionen muss daher mit viel Umsicht erfolgen Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Befreundete Funktionen 2 Beispiel class C2; // klasse C2 bekannt machen class C1 { // klasse C1 deklarieren private: int val; public: C1() { val = 111; } // konstruktur friend int sum(C1, C2); // friend-funktion sum }; class C2 { // klasse C2 deklarieren private: int val; public: C2() { val = 222; } // konstruktor friend int sum(C1, C2); // friend-funktion sum }; Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Befreundete Funktionen 3 Definition der friend-Funktion int sum(C1 c1, C2 c2) { int s; s = c1.val + c2.val; return s } Nutzung der friend-Funktion int main() { C1 obj1; // objekt klasse C1 C2 obj2; // objekt klasse C2 ... cout << sum(obj1, obj2); // -> 333 } Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Befreundete Klassen 1 anstelle einzelner Funktionen lassen sich gleich auch alle Funktionen einer Klasse als friend festlegen class C1 { // Klasse deklarieren private: int val; public: C1() { val = 111; } // Konstruktur friend class C2; // Friend-Klasse }; class C2 { // Klasse deklarieren public: int quad(C1 c) { return c.val * 2; } }; ... C1 obj1; C2 obj2; cout << obj2.quad(obj1); // -> 222 Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Vererbung 1 Vererbung ist das Ableiten einer neuen Klasse aus einer bereits bestehenden Klasse (= Basisklasse)  eine neue Klasse erbt ggfs. alle Attribute und Methoden der Basisklasse  die gleiche Funktionalität muss nicht mehrfach implementiert werden  der Code wird wartungsfreundlicher, da er nur an einer Stelle, in einer Klasse verändert werden muss  abgeleitete Klassen sind i.d.R. Spezialisierungen der Basisklasse Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Vererbung 2 Beispiel: Klasse Pin für Arduino (Auszug) class Pin { // klasse deklarieren protected: int pin_; // pinnummer int mode_; // input oder output int value_; // high oder low ... // weitere attribute public: Pin(int p, int m) { ... } // konstruktur ~Pin(void) { ... } // destruktor void write(int v) { ... } // schreiben int read(void) { ... } // lesen ... // weitere Methoden }; protected - Zugriff für abgeleitete Klassen erlauben! Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Vererbung 3 Beispiel: abgeleitete Klasse Led class Led : public Pin { // klasse deklarieren public: Led(int p); // konstruktur ~Led(void); // destruktor void on(void); // led an void off(void); // led aus ... // weitere methoden }; Led::Led(int p) : Pin(p, OUTPUT) { // pin p auf output value_ = -1; // value_ aus Pin-Klasse } Led::on(void) { // led an pin p ein value_ = high; write(value_); // write aus Pin-Klasse } Led::off(void) { // led an pin p aus value_ = low; write(value_); // write aus Pin-Klasse } Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Privileg der Basisklasse Privileg der abgeleiteten Klasse Vererbung 4 Zugriffsrechte bei Ableitung / Vererbung Ableitung Privileg der Basisklasse Privileg der abgeleiteten Klasse public protected private Kein Zugriff kein Zugriff Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Funktions-Templates 1 Funktions-Templates sind Vorlagen / Schablonen, um einen Algorithmus unabhängig vom Typ der Parameter zu implementieren anderer Name: generische Funktionen Templates für Funktionen mit gleicher Funktionalität gleicher Anzahl von Parametern jeweils verschiedenen Typen der Parameter der Compiler erzeugt die passende Funktion abhängig von den Aufrufparametern zur Compilezeit guter Ersatz für parametrisierte CPP-Makros weitere Parameter sind möglich Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Funktions-Templates 2 Beispiel: Minimum als CPP-Makro #define min(p1, p2) (p1 < p2 ? p1 : p2) ... int a = min(47, 11); // textersatz!!! double d = min(47.11, 3.141); Beispiel: Minimum als Funktions-Template template <typename TYPE> TYPE min(TYPE p1, TYPE p2) { return p1 < p2 ? p1 : p2; } ... int a = min(47, 11); // echte Funktion! double d = min(47.11, 3.141); Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Funktions-Templates 3 explizite Spezifizierung der Parametertypen mit < > int a1, a2, m1, m2; ... m1 = min(-1, 1); // -> -1 m2 = min<unsigned int>(-1, 1); // -> 1 mehrere Parametertypen und lokale Variablen template <typename TYPE1, typename TYPE2> TYPE1 minimum(TYPE1 p1, TYPE2 p2) { TYPE1 loc = TYPE1(p2); return p1 < loc ? p1 : loc; } ... int a = min(17, 17.56); Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Funktions-Templates 4 auch Template-Parameter template <typename TYPE> TYPE summe(TYPE af[], int n) { TYPE sum = TYPE(0); for(int i = 0; i < n; i++) sum += af[i]; return sum; } ... int si, fi[] = { 1, 2, 3, 4, 5, 6 }; double sd, fd[] = { 1.1, 2.2, 3.3, 4.4 }; si = summe(fi, 6); sd = summe(fd, 4); Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Klassen-Templates 1 nicht nur für Funktionen, auch für Klassen sind Templates möglich, um Klassen unabhängig von Datentypen zu implementieren und zur Compilezeit für den oder die jeweiligen Typen zu erzeugen anderer Name: generische Klassen Templates sind sinnvoll für Klassen mit gleicher Funktionalität gleichen Attributen / Daten gleichen Methoden / Funktionen jeweils verschiedenen Datentypen von Attributen /Daten und Methoden/Funktionen Vorteil: Klasse nur einmal designen und implementieren Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Klassen-Templates 2 Beispiel: Templateklasse für unterschiedliche Zahlentypen // deklaration und implementierung template <typename T> class Zahl { public: Zahl(T z1, T z2) { z1_ = z1; z2_ = z2; } void set(T z1, T z2) { z1_ = z1; z2_ = z2; } T summe(void) { return z1_ + z2_; } private: T z1_; T z2_; }; // Definition mit Typisierung und Nutzung Zahl<int>zi(3, 4); // klasse fuer int Zahl<double>zd(3.1, 4.2); // klasse fuer double cout << zi.summe() << endl; // -> 7 cout << zd.summe() << endl; // -> 7.3 Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Klassen-Templates 3 i.d.R. werden Klassen und so auch Templateklassen in eigenen Dateien gespeichert // Zahl.h #ifndef _ZAHL_H #define _ZAHL_H template <typename T> class Zahl { public: Zahl(T z1, T z2) { z1_ = z1; z2_ = z2; } void set(T z1, T z2) { z1_ = z1; z2_ = z2; } T summe(void) { return z1_ + z2_; } private: T z1_; T z2_; }; #endif auffällig: Implementierung der Klasse in der Headerdatei! Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Klassen-Templates 4 Erinnerung: zur Compilezeit passiert die Spezifizierung von Templates Festlegung auf konkrete Datentypen Erzeugung des Objektcodes  der Compiler muss daher die Implementierung der generischen Klassen kennen  der Compiler muss Zugriff auf den Code haben  Implementierung der Klasse in Headerdatei  ggfs. Includieren der Implementierungsdatei in der Headerdatei am Dateiende: ... #include "Zahl.cpp" Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Klassen-Templates 5 die Implementierung von Templateklassen in den Klassen-Headerdateien ist der einfachste Weg der Modularisierung von Templateklassen das ist nicht schön, aber pragmatisch! die Aufteilung in Headerdatei .h mit der Deklaration und Implementierungsdatei .cpp ist möglich, macht aber die Spezifizierung der Templateklasse z.B. in der cpp-Datei notwendig  zur Compilezeit der Klassendateien wird Typisierung und Erzeugung des Objektcodes für die Datenypen der Templateklasse vorgenommen  Spezifizierung der Templateklasse für weitere Daten-typen im eigenen Code ist danach nicht mehr möglich Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Klassen-Templates 6 Beispiel // Zahl.cpp #include "Zahl.h" // Implementierung der Templateklasse Zahl template <typename T> Zahl<T>::Zahl(T z1, T z2) { z1_ = z1; z2_ = z2; } template <typename T> void Zahl<T>::set(T z1, T z2) { z1_ = z1; z2_ = z2; } template <typename T> T Zahl<T>::summe(void) { return z1_ + z2_; } // Typisierung fuer int und double template class Zahl<int>; template class Zahl<double>; Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI

Klassen-Templates 7 die Templateklasse Zahl ist hiermit nur für die Typen int und double verwendbar der Compiler schluckt zwar die Spezifierung für weitere Datentypen, z.B. float #include "Zahl.h" Zahl<int>zi(3, 4); // ok! Zahl<double>zd(1.1, 5.5); // ok! Zahl<float>zf(4.7, 1.1); // wirklich ok? Doch der Binder ld kann die Referenz nicht auflösen Undefined first referenced symbol in file Zahl<float>::Zahl(float, float) /var/tmp/cc2watNc.o ld: fatal: Symbol referencing errors. No output written to a.out collect2: ld returned 1 exit status Programmieren in C / C++ - Peter Klingebiel - HS Fulda - FB AI