C++11 – C++17 – Ergänzungen

auto

Neues key-word erlaubt vereinfachte Deklaration von Variablen aus Kontext, z.B.:

// C++ 11

map< string, string > engdeut;

for ( auto it = engdeut.begin(); it != engdeut.end(); ++it ) { ....

// C++ 03

map< string, string > engdeut;

for ( map<string,string>::iterator it = engdeut.begin(); it != engdeut.end(); ++it ) { ....

for-each

Vereinfachte Schleife über Container mit direktem Zugriff auf jedes Element (for-each Loop in anderen Sprachen), z.B.

// C++ 11

vector<double> vec1; ...

for( auto x : vec1 ) {

cout << x;

};

// C++ 03

vector<double> vec1; ...

for(int i=0; i<vec1.size(); i++) {

cout << vec1[i];

};

tuple

Container um Objekte verschiedenen Typs und beliebiger Anzahl zu gruppieren (wie pair, aber auch für $\bgroup\color{dgreen}$>=2$\egroup$ Objekte):

// C++ 11

tuple<int,float,string> t(1,2.f,"text");

int x = get<0>(t);

float y = get<1>(t);

string z = get<2>(t);

lambda Funktionen

sind "anonyme" Funktionen, sehr praktisch als Argument bei Aufruf von anderen Funktionen, z.B. STL Algorithmen die Funktion-Objekt bzw. Functor als Argument erwarten:

vector <double> vec2; ....

// lambda funktion als 3. Argument, sortiert vector nach Betrag

sort(vec2.begin(), vec2.end(), [](double x, double y) { return abs(x)<abs(y);} );

Speicher–Management – Smart Pointer

Smart Pointer mit memory management ( shared_ptr)

Für bestimmte Probleme braucht man dynamisch angelegte Arrays oder Objekte, z.B. wenn Funktion Objekt zurückgeben soll.

Bisher in C++ kein automatisches Memory Management im Standard–Sprachunfang, Programmierer muss sorgfältig darauf achten alle mit new angelegten Speicherbereiche auch mit delete wieder zurückzugeben, sonst memory leaks.

Großes Problem dabei sind auch dangling pointers, d.h. Speicherbereich wurde mit delete zurückgegeben, es gibt aber noch pointer, die darauf zeigen und evt. verwendet werden.

Mit C++–11 und shared_ptr automatisches Memory Management und Referenz-Zähler.

//....
// C++-03
My3Vector * vp = new My3Vector(1.0, 2.5, -0.8 ); // dynamisch angelegter 3-Vektor
cout << vp->Length() ; 
//...
My3Vector * vp2 = vp;

delete vp; // zurueckgeben

// vp2 ?? --> dangling pointer
//....
// ---------------------------------------------------------
// C++-11
#include <memory>
//...
shared_ptr<My3Vector> vp(new My3Vector(1.0, 2.5, -0.8 )); // dynamisch angelegter 3-Vektor mit shared_ptr
cout << vp->Length() ; // wie std pointer zu verwenden
//
// or alternativ:
auto vp = make_shared<My3Vector>(1.0, 2.5, -0.8 );

// make copy of it
shared_ptr<My3Vector> vp2(vp);
//
// kein delete noetig, shared_ptr hat Referenz-count und raeumt automatisch auf wenn kein Verweis mehr aktiv
//

shared_ptr kann fast universell für Memory Management verwendet werden und erlaubt damit ähnlich flexible und einfache Nutzung wie in Java oder Python. Es gibt daneben auch noch unique_ptr und weak_ptr, für spezielle Memory Management Probleme.

C++11 weitere Features und Kompilieren

Es gibt darüberhinaus noch viele weitere nützliche Features, z.B.

Threading
Vereinfachte Initialisierung von Member Variablen und Container Elementen
...

Mittlerweile ist die C++11 Funktionalität in der C++ Version am CIP standardmässig aktiviert.

Ansonsten, bei älteren gcc Versionen geht das mittels Option -std=c++11 , d.h. z.B.

g++ -std=c++11 -o myprog myprog.cpp