Initialisierungslisten sind in C++11 für alle Standardcontainer verfügbar. Damit lassen sich Vektoren und Arrays komfortabel initialisieren. Diese Funktion kann mit Hilfe von initializer_list (Link zu Beschreibung) aus dem Namensraum std auch bei benutzerdefinierten Datentypen eingebaut werden. Dieser Beitrag veranschaulicht den praktischen Entwurf einer Template Klasse, bei der verschiedene Maschinenparameter bei der Variablendefinition direkt initialisiert werden können.
Im ersten Schritt binden wir die notwendigen Headerdateien ein. Essentiell ist dabei natürlich das Modul initializer_list. Des Weiteren wollen wir Vektoren und Strings als Membervariablen in der Klasse verwenden.
|
1 2 3 4 5 |
// Header einbinden #include <iostream> #include <vector> #include <string> #include <initializer_list> |
Im nächsten Schritt definieren wir die Template Klasse Namens DeviceData.
|
1 2 3 4 |
template <typename T> struct DeviceData { }; |
Als Mitglieder der Klasse legen wir einen Vektor (parameter) an. Zusätzlich definieren wir zwei Strings für die Beschreibung der der Parameter (description_long und description_short). Es können eine lange Beschreibung und eine Kurzbeschreibung zugewiesen werden.
|
1 2 3 4 |
// Variablen für Parameterliste und Beschreibung std::vector<T> parameter; std::string description_long; std::string description_short; |
Wir definieren des Weiteren mehrere Konstruktoren. Neben dem Standardkonstruktor legen wir fest, dass das Objekt mit einem Vektor eines beliebigen Datentyps initialisiert werden kann. Weiters kann mit Hilfe der beiden nächsten Konstruktoren zusätzlich eine lange Beschreibung und eine Kurzbeschreibung mit initialisiert werden. Das Schlüsselwort ist dabei std::initializer_list. Alle Parameter werden direkt zugewiesen, die Funktionskörper bleiben leer.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
// Standardkonstruktor DeviceData() {}; // Konstruktor für Parameterliste DeviceData(std::initializer_list<T> p) : parameter(p) {} // Konstruktor für Parameterliste + lange Beschreibung DeviceData(std::initializer_list<T> p, std::string ds) : parameter(p), description_long(ds) {} // Konstruktor für Parameterliste + lange Beschreibung + Kurzbeschreibung DeviceData(std::initializer_list<T> p, std::string ds, std::string dl) : parameter(p), description_long(ds), description_short(dl) {} |
Zur Ausgabe der Inhalte implementieren wir eine Funktion, die Maschinenparameter mit einer for Schleife ausgibt. Sofern die Variablen für die Beschreibungen der Parameter einen Text beinhalten wird dieser ebenfalls ausgegeben.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// Funktion zur Ausgabe der Geräteparameter und Beschreibungen void printDeviceData() { // Parameterliste ausgeben for (auto &it : parameter) { std::cout << it << ", "; } std::cout << '\n'; // Lange Beschreibung ausgeben if (description_long != "") { std::cout << description_long << '\n'; } // Kurzbeschreibung ausgeben if (description_short != "") { std::cout << description_short << '\n'; } } |
In unserer Hauptroutine können wir nun mehrere Objekte vom Typ DeviceData anlegen. Als erstes definieren wir mit device_info eine Variable die ausschließlich Texte zur Beschreibung der Maschine enthält. Die weiteren Variablen machen von den anderen Konstruktoren Gebrauch. Wir legen zwei Variablen mit Langtext an (parameter_start und offset_device_A1) und eine Variable mit zusätzlichem Kurztext (offset_device_A2). Der Datentyp der Vektors wird dabei variiert. Es ist notwendig, zusätzliche geschwungene Klammern zu verwenden, um die Vektorliste und die Strings voneinander zu trennen.
Zum Schluss erzeugen wir noch ein Array unseres Datentyps mit Startwerten für einen fiktiven Testlauf (parameter_testrun). Die beiden Elemente werden ebenfalls sofort mit jeweils drei Werten initialisiert.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// Parameterdaten initialisieren mit Initialisierungsliste DeviceData<std::string> device_info {"Typ: 33", "Seriennummer: B56879", "Lieferdatum: 20101103"}; DeviceData<int> parameter_start {{15, 23, 8, 7}, "Füllmengen Behälter C1 - C3"}; DeviceData<double> offset_device_A1 {{1.45, 2.78, 0.98}, "Offset x y z für Greifarm B7"}; DeviceData<double> offset_device_A2 {{1.45, 2.78, 0.98}, "Offset x y z für Greifarm B8", "Offset B8"}; // Array mit Parameterdaten erzeugen DeviceData<int> parameter_testrun[2] {{5, 8, 3}, {1, 2, 4}}; |
Wir können nun mit Hilfe der von uns definierten Memberfunktion printDeviceData() die zuvor angelegten Variablen ausgeben.
|
1 2 3 4 5 6 7 |
// Parameterdaten ausgeben device_info.printDeviceData(); parameter_start.printDeviceData(); offset_device_A1.printDeviceData(); offset_device_A2.printDeviceData(); parameter_testrun[0].printDeviceData(); parameter_testrun[1].printDeviceData(); |
Typ: 33, Seriennummer: B56879, Lieferdatum: 20101103,
15, 23, 8, 7,
Füllmengen Behälter C1 - C3
1.45, 2.78, 0.98,
Offset x y z für Greifarm B7
1.45, 2.78, 0.98,
Offset x y z für Greifarm B8
Offset B8
5, 8, 3,
1, 2, 4,
Wir erkennen an Hand der Ausgabe, dass alle definierten Variablen ordnungsgemäß initialisiert wurden.
Das Beispiel kann mit folgendem Befehl kompiliert und ausgeführt werden:
g++ -std=c++11 cpp_initializer_list.cpp && ./a.out
Das komplette Beispiel herunterladen: cpp_initializer_list.zip
Hinterlasse jetzt einen Kommentar