Das Dokument beschreibt die Entwicklungen und Neuerungen in den C++-Standards von C++11 und C++14, einschließlich wesentlicher Merkmale wie Rvalue-Referenzen, Move-Semantik und die Einführung von Smart Pointern. C++11 zielt darauf ab, die Sprache besser für Systemprogrammierung und Bibliotheksentwicklung zu machen, während C++14 Feinabstimmungen vornimmt. Es wird auch betont, dass C++ sicherere Praktiken fördert und alte C-Konzepte, die zu Problemen führen können, aufgibt.

1. C++11 und C++14
Was bringen die neuen Standards?
Holger Jakobsholger@jakobs.com – http://plausibolo.de

2. kurze Geschichte von C++
●Erfinder von C++ ist BjarneStroustrup
●1979: C with Classes
●1984: Umbenennung in C++
●1985: C++ 1.0
●1989: C++ 2.0
●1998: ISO C++
●2011: ISO C++11
●2014: ISO C++14

3. Haupt-Eigenschaften
●Code läuft als nativer Code direkt auf Hardware – keine virtuelle Maschine.
●Code ist typsicher (weitestgehend, Ausnahmen beruhen auf C-Kompatibilität).
●Destruktoren räumen den Speicher auf, keine Garbage Collection – denn Speicher ist nicht alles!
●Objekte werden auf dem Stack erzeugt, nicht ständig mit new auf dem Heap!

4. Haupt-Eigenschaften
●C++ gehört niemandem.
●Es gibt eine umfangreiche Standardbibliothek, aber ihr fehlen noch wesentliche Dinge:
–GUI-Programmierung (große Auswahl vorhanden: Qt, Tk, Gtk+, wxWidgets, … – aber kein Standard)
–XML-Bibliothek
–Unterstützung für Web-Programmierung

5. C++ 1.0 - 1985
Hauptsächliche Neuigkeiten:
●Overloading von Funktionen/Methoden
●virtuelle Funktionen, virtual
●Referenzen als Ergänzung zu Zeigern
●echte Konstanten
●Kommentare mit //

6. C++ 2.0 - 1989
Hauptsächliche Neuigkeiten:
●Mehrfachvererbung
●abstrakte Klassen
●statische Methoden
●Schlüsselwort protected

7. ISO C++98
●STL wurde Teil der C++ Standard Library
●Deklaration von lokalen Laufvariablen in for
●Typecasts: a = double (y);
●Weglassen des .h beim #include: #include <iostream>
●Namespaces, Datentypen string bool
●stringstream statt strstream
●eine Reihe neuer Schlüsselwörter

8. ISO C++11
●Eigentlich war C++0x geplant …
●Ziele (Stroustrup)
–Make C++ a better language for systems programming and library building
–Make C++ easier to teach and learn
●Stroustrup: The range of abstractions that C++ can express elegantly, flexibly, and at zero costs compared to hand-crafted specialized code has greatly increased.

9. Neuerungen in ISO C++11
●Rvalues und Move Semantics
●echte enum-Typen
●long long (mind. 64 bit)
●generalisierte konstante Ausdrücke constexpr
●Nullpointer nullptr
●Kontrolle durch default delete
●Typherleitung durch auto
●Initialisierung durch { … }

10. Neuerungen in ISO C++11
●static_assert
●raw Strings
●Lambda-Ausdrücke
●reguläre Ausdrücke (bei g++ erst ab 4.9)
●Threads
●variabel lange Parameterlisten für Templates
●„smart“ pointers
●Zeitbibliothek chrono

11. Rvalue und Move-Semantics
●Kopierkonstruktor X(const X&);
●neu: Move-Konstruktor X(X&&);
●Zuweisung X& operator=(const X&);
●neu: Move-Zuweisung X& operator=(X&&);
●Gründe hierfür:
–Speicherplatz sparen
–Performance verbessern
–Rückgabemöglichkeit ohne Zeiger

12. Rvalue und Move-Semantics
●siehe matrix-move.cpp
●Was man nicht machen darf: mit new neuen Speicher in operator+ holen und dann eine Referenz darauf zurückgeben.
●Grund: Wer ist für die Dereferenzierung verantwortlich? Was passiert, wenn vor der Rückgabe eine Exception geworfen wird?
●Also: Nirgendwo new machen, wo das zugehörige delete nicht dabei ist.

13. Rvalue und Move-Semantics
●Compiler erzeugt automatisch:
–default-Konstruktor
–copy-Konstruktor und copy-Zuweisung
–move-Konstruktor und move-Zuweisung
–Destruktor
●Wenn man nur eines davon selbst definiert, fehlen die anderen!
●Lösung (hier am Beispiel des move-Konstruktors): X(X&&) = default;

14. Rvalue und Move-Semantics
●Woher weiß der Compiler, ob er move oder copy machen soll?
●Bei Werterückgaben weiß er das.
●sonst Hinweis geben mit std::move(x); template <typename T> void swap (T &a, T &b) { T tmp = std::move(a); a = std::move(b); b = std::move(tmp); }

15. Consider how to return a potentially large number of elements from a function. Here is a conventional C++98 function returning the indices of string matches:
vector<int>* find_all (vector<string>& vs, const string& s) { vector<int>* res = new vector<int>; for (int i = 0; i < vs->size(); ++i) if (vs[i] == s) res->push_back(i); return res; }
vector<int>* pvi = find_all(some_vec,"vindaloo"); for (vector<int>::iterator p = pvi->begin(); p!=pvi->end(); ++p) cout << *p << " is a matchn"; // … delete pvi;
Quelle: http://www.informit.com/articles/article.aspx?p=2080042
sonst: memory leak!

16. Move semantics allows a significant simplification:
vector<int> find_all(vector<string>& vs, const string& s) { vector<int> res; for (int i = 0; i<vs.size(); ++i) if (vs[i] == s) res.push_back(i); return res; }
for (int x: find_all(some_vec,"vindaloo")) cout << x << " is a matchn";
Auch die Wiedergabe ist viele einfacher!
Natürlich kann es auch kein Memory Leak geben, denn es muss nichts mit delete freigegeben werden.
move-Semantik

17. unique_ptr und shared_ptr
●unique_ptr kann nicht kopiert werden.
●Ihm gehört der Speicher, auf den er zeigt.
●Geht er out of scope, gibt er den Speicher frei.
●Eigentümerschaft kann übertragen werden.
●shared_ptr kann mehrere Eigentümer haben.
●Er hat einen Referenzzähler.
●Geht der Zähler auf 0, wird der Speicher freigegeben.

18. weak_ptr
●weak_ptr zeigt auf einen shared_ptr
●Referenzzähler wird für weak_ptr nicht hochgezählt.
●Daher kann das Objekt auch jederzeit gelöscht werden.
●Vor Zugriff muss er in einen shared_ptr umgewandelt werden mittels lock()

19. Was sollten C-Programmierer sofort vergessen?
Eigentlich alles, was Stress macht bzw. gefährlich ist (buffer overflow):
●Zeichenketten à la C, also char[] und char*, stattdessen string verwenden!
●Alle Arrays, stattdessen Standardcontainer verwenden: array vector list deque forward_list set map
●C-I/O wie printf() fprintf() fgets(), stattdessen iostream verwenden.
●Zeiger zur Parameterübergabe oder Wertrückgabe, stattdessen const& und Move-Semantik verwenden

20. Neu in C++14
C++14 ist nur ein Finetuning, nicht vergleichbar mit C++11
void sort(Container& c); vector<string> vs {"Hello", "new", "World"}; sort(vs);// fine: vs is a Container
template<Sortable Cont> void sort(Cont& container); vector<double> vec {1.2, 4.5, 0.5, -1.2}; list<int> lst {1, 3, 5, 4, 6, 8,2}; sort(vec);// OK: a vector is Sortablesort(lst); // Error at (this) point of use: // Sortable requires random access

21. Neu in C++14
template<class T> constexpr T pi = T(3.1415926535897932385);
//C++14, a variable template in usetemplate<typename T> T circular_area(T r) { return pi<T> * r * r; }
double darea = circular_area(5.5); //uses pi<double>
float farea = circular_area(5.5f); //uses pi<float>
Template-Variablen sind nicht auf eingebaute Typen beschränkt. matrix<T>, complex<T> usw. gehen auch.

22. Danke für eure Zeit und Aufmerk- samkeit!
Holger@Jakobs.com http://plausibolo.de