Zusammenfassung. Mit bjam und ein paar Zeilen in einem Jamroot oder Jamfile lässt sich das Kompilieren und Linken einfach automatisieren

Transkript

1 Zusammenfassung Deklaration einer Klasse im Header-File /.h-file Header-Files mit #pragma once vor double inclusion schützen möglichst Vorwärts-Deklarationen verwenden statt include-files einzubinden mindestens ein ctor, genau ein dtor nur die von aussen zugänglichen Member-Funktionen/Methoden sind public Member, die von abgeleiteten Klassen benutzt werden sollen, sind protected, alles andere ist private Implementierung einer Klasse im.cc-file den scope aller Member-Funktionen mit classname:: angeben System-Header mit #include <header> einbinden, eigene Header mit #include file Instanzen einer Klasse (Objekte) können (wie normale Variablen) statisch angelegt werden, oder während der Laufzeit mit new dynamisch erzeugt und mit delete vernichtet werden Mit bjam und ein paar Zeilen in einem Jamroot oder Jamfile lässt sich das Kompilieren und Linken einfach automatisieren

2 Vererbung, Basisklassen, abstrakte Basisklassen, Templates Fast immer haben mehrere Klassen gemeinsame Eigenschaften und gemeinsame Funktionalität. Das public interface und die für eine Gruppe von Klassen gemeinsamen Dinge steckt man in eine Basisklasse. Die speziellen Klassen werden von der Basisklasse abgeleitet; sie erben von der Basisklasse. In C++ ist Mehrfachvererbung möglich. Vererbung sorgt dafür, dass man diese gemeinsamen Dinge nur einmal implementieren muss. Vererbung sorgt dafür, dass man Erweiterungen und Bugfixes für die Gemeinsamkeiten nur an einer Stelle vornehmen muss. Code-Duplikation muss man unbedingt vermeiden! Wenn die speziellen Klassen nur das Interface gemeinsam haben, gibt es in der Basisklasse keine Implementierungen: abstrakte Basisklasse (interface in Java). Verschiedene Klassen mit dem selben geerbten (abstrakten) Interface können von anderen Klassen alle gleich behandelt werden. Unmengen von Fallunterscheidungen fallen einfach weg! Beispiel: Erzeugt mit git clone eine Kopie des Multimeter-Beispielprojektes. Das git-repository findet ihr in /home/tau/matthias/multimeterexample. Schaut euch an, wie die Klasse Multimeter und die Klassen Keithley617, Keithley619, DummyMeter, etc. zusammen hängen. Programmiert wieder ein main(), das je nach übergebenem Argument ein konkretes Multimeter erzeugt, und eine Funktion aufruft, die dieses Multimeter unabhängig von dessen konkretem Typ eine Zeit lang alle paar Sekunden ausliest. Einschub: Schaut euch an, wie in DummyMeter gaussverteilte Zufallszahlen erzeugt werden, und was boost::math und boost::random noch zu bieten haben. All die Dinge aus Fritz-Herbert s Vorlesung und viele Sachen, die man in PWAs braucht, gibt es in Boost schon!

3 Vererbung, Basisklassen, abstrakte Basisklassen, Templates #pragma once class Multimeter Multimeter(); virtual ~Multimeter(); virtual double measure() = 0; virtual double current() = 0; virtual double voltage() = 0; protected: ; enum Mode Current, Voltage, undefined; Mode mode; #pragma once #include "Multimeter.hh" class Keithley619 : public Multimeter Keithley619(); virtual ~Keithley619(); virtual double measure(); virtual double current(); virtual double voltage(); private: void send(const char* line); double input(); int fd; ; Compiler erzeugen für jede Klasse eine Virtual Function Table Bei der Vererbung werden die Einsprungadressen der Methoden der Tochterklasse in der VFT eingetragen

4 Vererbung, Basisklassen, abstrakte Basisklassen, Templates #pragma once #include "Multimeter.hh" #include <boost/random.hpp> #include <boost/random/normal_distribution.hpp> class DummyMeter : public Multimeter DummyMeter(); virtual ~DummyMeter(); virtual double measure(); virtual double current(); virtual double voltage(); private: boost::mt19937 randomgenerator; boost::normal_distribution<> gaussdistribution; boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > gaussgenerator; ; #include "DummyMeter.hh" DummyMeter::DummyMeter() : gaussdistribution(7.3e-4, 2.2e-5), gaussgenerator(randomgenerator, gaussdistribution) mode = Multimeter::Current; DummyMeter::~DummyMeter() double DummyMeter::measure() return gaussgenerator(); double DummyMeter::current() if (!(mode == Multimeter::Current)) mode = Multimeter::Current; return measure(); double DummyMeter::voltage() if (!(mode == Multimeter::Voltage)) mode = Multimeter::Voltage; return measure();

5 Templates Function templates are special functions that can operate with generic types. This allows us to create a function template whose functionality can be adapted to more than one type or class without repeating the entire code for each type. ( // function template #include <iostream> using namespace std; template <class T> T GetMax (T a, T b) T result; result = (a>b)? a : b; return (result); int main () int i=5, j=6, k; long l=10, m=5, n; k=getmax<int>(i,j); n=getmax(l,m); cout << k << endl; cout << n << endl; return 0; Die Definition des Templates muss für den Compiler sichtbar sein, wenn das Template benutzt wird. Erst wenn ein Template instanziert wird, erzeugt der Compiler Code für den benötigten Typ. Die Definition des Templates erzeugt noch keinen Code. Dies ermöglicht header-only-libraries. Beim Instanzieren wird der Type in < >-Klammern angegeben. Ist es auch diese Angabe eindeutig, welchen Typ der Compiler benutzen soll, kann man die < >-Klammern auch weg lassen. Ein Template kann auch von mehreren Typen abhängen: template <class T, class U> Auch normale Parameter können Template-Parameter sein: template <class T, int N> T tarray[n]...

6 Klassen-Templates We also have the possibility to write class templates, so that a class can have members that use template parameters as types. ( template <class T> class mypair private: T values [2]; mypair (T first, T second) values[0]=first; values[1]=second; ; mypair<int> myobject (115, 36); mypair<double> myfloats (3.0, 2.18); Manchmal sieht der Code für einen Type anders aus als für die meisten anderen: template specialization // template specialization #include <iostream> using namespace std; // class template: template <class T> class mycontainer T element; mycontainer (T arg) element=arg; T increase () return ++element; ; // class template specialization: template <> class mycontainer <char> char element; mycontainer (char arg) element=arg; char uppercase () if ((element>='a')&&(element<='z')) element+='a'-'a'; return element; ; int main () mycontainer<int> myint (7); mycontainer<char> mychar ('j'); cout << myint.increase() << endl; cout << mychar.uppercase() << endl; return 0; Wie sieht die Ausgabe von main() aus?

7 Klassen-Templates Zusammenfassung Templates ermöglichen Funktionen und Klassen, die generische, erstmal noch unbestimmte Typen benutzen Template-Parameter werden von Kommas getrennt in < >-Klammern angegeben Nicht nur Typen, sondern auch normale Paramter können Template-Parameter sein Template specialization ermöglicht verschiedenen Code für verschiedene Typen Erst die Instanzierung eines Templates erzeugt Code: header-only-libraries