C++11 stellt einen der bedeutendsten Schritte in der Modernisierung von C++ dar. Diese Version brachte zahlreiche neue Funktionen, die Speicherverwaltung vereinfachen, die Performance verbessern und einen klareren, sichereren Programmierstil ermöglichen. In diesem Artikel betrachten wir die wichtigsten Neuerungen von C++11 anhand verständlicher Beispiele.


1) Das Schlüsselwort auto

Mit auto kann der Compiler den Variablentyp automatisch aus dem Initialisierungsausdruck ableiten. Dadurch wird der Code kürzer und besser lesbar.


auto x = 10;          // int
auto pi = 3.14;       // double
auto name = "Johann"; // const char*

2) Range-based for-Schleife

Eine moderne und sichere Möglichkeit, Container zu durchlaufen.


vector<int> werte = {1, 2, 3};

for (auto w : werte) {
    cout << w << endl;
}

3) nullptr

nullptr ist ein typsicheres Nullzeiger-Literal und ersetzt das traditionelle NULL.


int* p = nullptr;

4) Lambda-Ausdrücke

Lambda-Ausdrücke ermöglichen das Definieren kleiner, anonymen Funktionen an Ort und Stelle.


auto greet = [](const string& name) {
    cout << "Hallo, " << name;
};

greet("Laura");

5) Smart Pointer (unique_ptr, shared_ptr, weak_ptr)

Smart Pointer gehören zu den bedeutendsten Neuerungen von C++11. Sie übernehmen die automatische Speicherverwaltung und reduzieren Speicherlecks erheblich.

unique_ptr


#include <memory>

unique_ptr<int> p = make_unique<int>(42);

shared_ptr


shared_ptr<string> s1 = make_shared<string>("Michael");
shared_ptr<string> s2 = s1; // Referenzzähler steigt

weak_ptr


weak_ptr<string> wp = s1; // verhindert zyklische Referenzen

6) Move Semantics (&&)

Move Semantics ermöglichen das Verschieben von Ressourcen statt einer teuren Kopie. Besonders vorteilhaft bei temporären Objekten oder großen Datenmengen.


string a = "Hallo Welt";
string b = std::move(a); // Verschieben statt Kopieren

7) constexpr

Mit constexpr können Ausdrücke zur Kompilierzeit ausgewertet werden, was die Ausführungsgeschwindigkeit verbessern kann.


constexpr int quadrat(int x) {
    return x * x;
}

int y = quadrat(7);

8) std::array

Ein sicherer, STL-kompatibler Ersatz für klassische C-Arrays mit fester Größe.


#include <array>

array<int, 3> arr = {10, 20, 30};

9) enum class

Eine stark typisierte Enumerationsart, die Namenskonflikte vermeidet und sicherer ist als klassische enums.


enum class Status { Online, Offline, Busy };

Status userStatus = Status::Online;

10) Initializer Lists

Vereinfachen die Initialisierung von Containern und Objekten mittels {...}.


vector<string> namen = {"Johann", "Laura", "Michael"};

11) static_assert

Ermöglicht Prüfungen zur Kompilierzeit, sodass Fehler früh entdeckt werden.


static_assert(sizeof(long) >= 8, "long muss mindestens 8 Bytes groß sein");

12) std::tuple

Ermöglicht das Speichern mehrerer Werte unterschiedlichen Typs in einer einzigen Struktur.


auto person = make_tuple("Johann", 28, 1.80);

13) Fazit

C++11 brachte grundlegende moderne Funktionen, die die Sprache nachhaltig geprägt haben. Verbesserungen in Speicherverwaltung, Performance und Ausdruckskraft bilden die Basis für modernes C++.

14) TL;DR

  • auto → automatische Typableitung
  • range-based for → einfache Iteration
  • nullptr → typsicherer Nullzeiger
  • Lambda → anonyme Inline-Funktionen
  • Smart Pointer → sichere Speicherverwaltung
  • Move Semantics → effizientes Verschieben
  • constexpr → Auswertung zur Kompilierzeit
  • std::array, enum class, tuple → moderne Datentypen
  • Kompatibel mit Visual Studio 2022 und GCC