Moderne C++-Features, die von durch Clang erweiterte C++-Compiler in RAD Studio unterstützt werden

Inhaltsverzeichnis

1 C++17-Features, die von durch Clang erweiterte Compiler unterstützt werden
2 C++14-Features, die von durch Clang erweiterte Compiler unterstützt werden
3 C++11-Features, die von durch Clang erweiterte Compiler unterstützt werden
4 Siehe auch

C++17-Features, die von durch Clang erweiterte Compiler unterstützt werden

Die durch Clang erweiterten Compiler für Win32 und Win64 (bcc32c/bcc32x und bcc64) implementieren den gesamten ISO C++17-Standard (EN).

Zu den interessanten Funktionen von C++17 zählen folgende:

Constexpr if – Ergänzung für Compilierzeit-Ausdrücke.
string_view – Ergänzung für den schreibgeschützten Zugriff (keine Kopien, d. h. wenig Aufwand und schnell) auf eine Vielzahl von String-Typen.
If-init – Initialisierung einer Variable in einer if-Anweisung
Strukturierte Bindungen
Inline-Variablen
std::optional, std::variant, std::any, and std::filesystem – bekannte Klassen für Benutzer von Boost oder der experimentellen Bibliothek, nützlich für die Aufnahme vorhandener oder nicht vorhandener Werte, bessere Unions und mehr
Parallele Algorithmen – zur Verwendung der Standardalgorithmen in <algorithm> mit einer Vielzahl von Parallelisierungsstrategien

Weitere Informationen zu C++17:

Github-Dokument von Tony Van Eerd (EN), in dem alle Features mit Beispielen aufgeführt sind. Der Artikel bietet eine sehr gute Übersicht.
Dieser sehr detaillierte Blogbeitrag (EN) behandelt auch alle Neuerungen in C++17.

C++14-Features, die von durch Clang erweiterte Compiler unterstützt werden

Die durch Clang erweiterten Compiler für Win32 und Win64 (bcc32c/bcc32x und bcc64) implementieren den gesamten ISO C++14-Standard (EN).

Zu den interessanten Funktionen von C++14 zählen folgende:

Rückgabetypableitung mit auto
Lambdas mit generischen Parametern (über auto)
Variablen-Templates

Weitere Informationen zu C++14:

Dieser Artikel von Dr. Dobb (EN) bietet eine gute Übersicht (mit Code) über die neuen Elemente in C++14.
Dieses Github-Dokument von Anthony Calandra (EN) enthält Informationen über Neuerungen in allen C++-Versionen ab C++11.

C++11-Features, die von durch Clang erweiterte Compiler unterstützt werden

Diese Übersicht enthält die von den durch Clang erweiterten C++-Compilern von RAD Studio unterstützten C++11-Features. Die von den einzelnen C++-Compilern aus RAD Studio unterstützten C++11-Features finden Sie unter Konformitätsstatus moderner C++-Sprach-Features.

Bcc32c und bcc32x (durch Clang erweiterte Compiler für Win32) implementieren den gesamten ISO C++11-Standard (EN).
Ältere durch Clang erweiterte C++-Compiler unterstützen die C++11-Features teilweise:
- Die Haupt-Features von C++11 können mit BCCIOSARM64 verwendet werden. Dazu zählen unter anderem: variadische Templates, statische Assertions, der Multi-Deklarator "auto" und Lambda-Ausdrücke.
- Standard-C++11-Features (Laufzeit-Features) werden von BCCIOSARM64 nicht unterstützt. Dazu zählen unter anderem: Initialisierung von Klassenobjekten durch R-Werte und "Atomic"-Operationen.
BCC32 unterstützt auch die C++11-Features, die unter C++11-Features im klassischen Compiler beschrieben sind.

Hinweis: Wenn Sie für C++11 spezifische Schlüsselwörter, wie nullptr, noexcept usw. (eine vollständige Liste finden Sie unter http://en.cppreference.com/w/cpp/keyword) verwenden, erkennt die RAD Studio-IDE diese Schlüsselwörter immer, aber die C++-Compiler der vorherigen Generation (BCC32 und BCCOSX) geben einen Compiler-Fehler zurück. Beachten Sie bitte, dass nur durch Clang erweiterte C++-Compiler den C++11-Standard unterstützen.

Beschreibung der R-Wert-Referenzen

Das Feature "R-Wert-Referenzen" wird von BCC32 und den durch Clang erweiterten C++-Compilern unterstützt.

Weitere Informationen zu diesem Feature finden Sie unter R-Wert-Referenzen.

R-Wert-Referenzen für *this

Mit dem C++11-Feature "R-Wert-Referenzen für *this" können die Vorteile der Verschiebe-Semantik für den impliziten *this-Parameter übernommen werden.

Weitere Informationen zu diesem Feature finden Sie unter Rvalue references for *this Proposal document (EN).

Initialisierung von Klassenobjekten durch R-Werte

Der C++11-Standard führt für das Schreiben von klarem, knappem und effizientem Code die Möglichkeit ein, Klassenobjekte mit R-Werten zu initialisieren.

Das bedeutet, dass temporäre Variablen jetzt direkt mit dem gesamten R-Wertobjekt initialisiert werden, anstatt einen Konstruktor zum Kopieren des Objekts in die temporäre Variable aufzurufen.

Weitere Informationen zu diesem Feature finden Sie unter Initialization of class objects by rvalues Proposal document (EN).

Initialisierung von nicht-statischen Daten-Membern

C++11 führt die Möglichkeit ein, nicht-statische Daten-Member in der Klassendeklaration zu initialisieren.

Die Initialisierungen für nicht-statische Daten-Member sind auf =initializer-clause und {initializer-list} beschränkt.

Weitere Informationen zu diesem Feature finden Sie im folgenden Beispiel oder im Vorschlagsdokument unter Non-static data member initializers Proposal document (EN).

Initialisierung von nicht-statischen Daten-Membern – Beispiel

#include <string>

struct B {
        B(int, double, double);
};

class A {
        int a = 7; // OK
        std::string str1 = "member"; // OK
        B b = {1, 2, 3.0}; //OK
        std::string str2("member");   // ill-formed
};

Variadische Templates

Variadische Templates beziehen sich auf Klassen- oder Funktions-Templates mit einer variablen Parameteranzahl.

Um dies zu erreichen, führt C++11 Parameterpakete ein, die eine Liste von Null oder mehr Parametern darstellen.

Weitere Informationen zu diesem Feature finden Sie unter Variadic templates Proposal document (EN).

Variadische Templates – Beispiel

Dieses kleine Beispiel zeigt die C++-Syntax von variadischen Templates.

template<class ... T>
class A {
        // template class body
};

template<char ... T>
class B {
        // template class body
};

A<>a1;
A<int, char>a2;
A < B < 'a' >> a3;

B<>b1;
B < 'a', 'b' > b2;

Erweitern von Template-Parametern variadischer Templates

Beim Experimentieren mit variadischen Templates wurden einige Beschränkungen hinsichtlich der template-Template-Parameter entdeckt.

Der C++11-Standard erweitert variadische template-Template-Parameter, um diese Beschränkungen zu beheben.

Weitere Informationen zu diesem Feature finden Sie unter Extending Variadic Template Template Parameters Proposal document (EN).

Initialisierungslisten

Das Feature "Initialisierungslisten" wurde im C++11-Standard erweitert.

Eine Initialisierungsliste stellt eine Liste sortierter Argumente in geschweiften Klammern dar, mit der Strukturen, Klassen und Arrays initialisiert werden.
Vor C++11 konnten nur Klassen, die der POD-Definition (Plain Old Data) entsprachen, mit Initialisierungslisten initialisiert werden. Jetzt können auch Klassen wie std::vector mit Initialisierungslisten initialisiert werden. Dies erfolgt mit der Template std::initializer_list<>, die als Argument an Konstruktoren oder andere Funktionen übergeben werden kann.

Statische Assertions

Das Feature "Statische Assertions" wird von BCC32 und den durch Clang erweiterten C++-Compilern unterstützt.

Weitere Informationen zu diesem Feature finden Sie unter Statische Assertions (C++11).

Automatisch typisierte Variablen

Mit dem C++11-Feature "Automatisch typisierte Variablen" können Programmierer eine Variable mit dem Typ auto deklarieren. Dieser Typ wird vom Initialisierungsausdruck der Variable abgeleitet. Das auto-Schlüsselwort wird als einfacher Typspezifizierer behandelt (kann mit * und & verwendet werden), und seine Semantik ist vom Initialisierungsausdruck abgeleitet.

Weitere Informationen zu diesem Feature finden Sie im Vorschlagsdokument zum C++11-Standard unter : auto-typed variables Proposal Document (EN).

Automatisch typisierte Variablen – Beispiele

int IntFunc() {}
bool BoolFunc() {}
char* CharSFunc() {}

int _tmain(int argc, _TCHAR* argv[]) {
        // x is int
        auto x = IntFunc();
        // y is const bool
        const auto y = BoolFunc();
        // w is char*
        auto w = CharSFunc();
        return 0;
}

Ein weiteres Beispiel für den Typ auto finden Sie hier: Generic vector sort (C++).

Multi-Deklarator "auto"

Der C++11-Standard beinhaltet die Multi-Variablenform für auto-Deklarationen, wie:

int* func(){}

int _tmain(int argc, _TCHAR* argv[])
{
        auto x = 3, * y = func(), z = 4;
        return 0;
}

Bei den auto-Ausdrücken für Multi-Deklaratoren gilt die Einschränkung, dass die Variablen über denselben Basistyp verfügen müssen.

Beispielsweise ist die folgende Codezeile wohlgeformt:

auto x = 3, y = new int;

weil x und y denselben Basistyp haben : int. Der folgende Code:

auto x = 3, y = 3.5;

erzeugt den Fehler: [bcc64 Error] File1.cpp(11): 'auto' wird in der Deklaration von 'x' als 'int' und in der Deklaration von 'y' als 'double' abgeleitet

Dieses Feature wird von den durch Clang erweiterten C++-Compilern unterstützt.

Weitere Informationen zu diesem Feature finden Sie im Vorschlagsdokument zum C++11-Standard unter Multi-declarator auto (EN).

Entfernen von "auto" als Speicherklassenspezifizierer

Im C++11-Standard wurde die Verwendung von auto als Speicherklassenspezifizierer vollständig entfernt. Dieses Feature wird von den durch Clang erweiterten C++-Compilern unterstützt.

Wenn in der C++-Anwendung auto als Speicherklassenspezifizierer verwendet wird, erhalten Sie von den durch Clang erweiterten C++Compilern die folgende Warnung:

Warnung: Der Speicherklassenspezifizierer "auto" ist in C++11 nicht zulässig und wird in zukünftigen Releases nicht unterstützt.

Weitere Informationen zu diesem Feature finden Sie im Vorschlagsdokument zum C++11-Standard unter Removal of auto as a storage-class specifier (EN).

Neue Funktionsdeklaratorsyntax

Dieses C++11-Feature ändert die Semantik von auto und führt die Syntax für Funktionsdeklaratoren ein. Der Typspezifizierer auto legt fest, dass der Typ einer deklarierten Variable von ihrem Initialisierungsausdruck abgeleitet oder explizit am Ende des Funktionsdeklarators festgelegt werden soll.

Weitere Informationen zu diesem Feature finden Sie im Vorschlagsdokument zum C++11-Standard unter New function declarator syntax (EN).

Deklarierter Typ eines Ausdrucks

Das Feature "Deklarierter Typ eines Ausdrucks" wird von BCC32 und den durch Clang erweiterten C++-Compilern unterstützt.

Weitere Informationen zu diesem Feature finden Sie unter Typ-Bezeichner decltype (C++11).

Unvollständige Rückgabetypen

Die Anforderung, dass der Typ eines Ausdrucks eines Funktionsaufrufs vollständig sein muss, wenn er als decltype-Parameter verwendet wird, ist nicht nur unnötig, sondern auch schädlich.

Wenn in C++11 der Parameter eines decltype-Ausdrucks ein Ausdruck eines Funktionsaufrufs ist, der einen Klassentyp zurückgibt, muss der Typ nicht vollständig sein. Außerdem wird auch kein temporäres Objekt für den Rückgabewert eingeführt, wodurch Speicherplatz eingespart und der Destruktor nicht aufgerufen wird.

Weitere Informationen zu diesem Feature finden Sie unter Incomplete return types Proposal document (EN).

Rechte spitze Klammern

In den durch Clang erweiterten C++Compilern erzeugen zwei aufeinanderfolgende rechte spitze Klammern keinen Fehler mehr, und diese Konstruktionen werden als dem C++11-Standard entsprechend behandelt.

Weitere Informationen finden Sie im C++11-Vorschlagsdokument unter Right angle brackets Proposal document (EN).

Rechte spitze Klammern – Beispiel

#pragma hdrstop
#pragma argsused

#include <tchar.h>
#include <stdio.h>

#include <vector>
typedef std::vector<std::vector<int> > Table;  // OK
typedef std::vector<std::vector<bool>> Flags;  // OK

int _tmain(int argc, _TCHAR* argv[]) {

        return 0;
}

Template-Standardargumente für Funktions-Templates

Da keine Standard-Template-Argumente für Funktions-Templates festgelegt werden konnten, war der Programmierstil lange Zeit eingeschränkt.

In C++11 können solche Standardargumente verwendet werden.

Weitere Informationen zu diesem Feature finden Sie unter Default template arguments for function templates Proposal document (EN).

Standard-Template-Argumente für Funktions-Templates – Beispiel

template<class T = int, class U = char>
void function() {
        // function body
}

int _tmain(int argc, _TCHAR* argv[]) {
        function<>();            // OK, template arguments are -> int char
        function<int>();         // OK, template arguments are -> char
        function<char, char>();  // OK, template arguments are -> char char
        return 0;
}

Beheben des SFINAE-Problems bei Ausdrücken

Durch den C++11-Standard wird das Problem Ersetzungsfehler ist kein Fehler (Substitution Failure Is Not An Error, SFINAE) für Ausdrücke behoben. Dies erfolgt durch das Zulassen vollständig allgemeiner Ausdrücke unter der Bedingung, dass die meisten von diesen Ausdrücken generierten Fehler als SFINAE-Probleme anstatt als Fehler behandelt werden.

Weitere Informationen zu diesem Feature finden Sie unter Solving the SFINAE problem for expressions Proposal document (EN).

Alias-Templates

Mit dem wachsenden Einsatz von parametrisierten Typen in C++ steigt der Bedarf an parametrisierten Typaliasen. In C++11 wurde dieses Feature dem Standard hinzugefügt.

Weitere Informationen zu diesem Feature finden Sie unter Alias templates Proposal document (EN).

Externe Templates

Das Feature "Externe Templates" wird von BCC32 und den durch Clang erweiterten C++-Compilern unterstützt.

Weitere Informationen zu diesem Feature finden Sie unter Externe Templates (C++11).

Nullzeigerkonstante

C++11 führt nullptr, die Nullzeigerkonstante, ein, um die Mehrdeutigkeit zwischen 0 und einem Nullzeiger zu beseitigen.

Das vorhandene Makro NULL ist unzureichend, weil es nicht zwischen der Integerzahl 0 in einem Funktionsaufruf, der eine Überladung mit einem int-Parameter enthält, und einem anderen mit einem char*-Parameter unterscheiden kann.

Deshalb ist nullptr jetzt ein reserviertes Wort. Die Integerzahl 0 wird nicht implizit in einen Zeigertyp konvertiert. Der Nullzeiger kann nur in einen Zeigertyp konvertiert werden.

Hinweis: Der Nullzeiger kann nicht in arithmetischen Ausdrücken verwendet, keinem integralen Wert zugewiesen und nicht mit einem integralen Wert verglichen werden.

Hinweis: Weitere Informationen finden Sie unter Null pointer constant Proposal document (EN).

Siehe nullptr.

Streng typisierte Aufzählungen

Das Feature "Streng typisierte Aufzählungen" wird von BCC32 und den durch Clang erweiterten C++-Compilern unterstützt.

Weitere Informationen zu diesem Feature finden Sie unter Streng typisierte Aufzählungen (C++11).

Forward-Deklarationen von Enums

Das Feature "Forward-Deklarationen von Enums" wird von BCC32 und den durch Clang erweiterten C++-Compilern unterstützt.

Weitere Informationen zu diesem Feature finden Sie unter Forward-Deklarationen von Enums (C++11).

Generalisierte konstante Ausdrücke

Im C++11-Standard wurde die Notion konstanter Ausdrücke generalisiert und Aufrufe einfacher Funktionen (constexpr-Funktionen) und Objekte mit benutzerdefinierten Typen einbezogen, die sich aus einfachen Konstruktoren (constexpr-Konstruktoren) zusammensetzen.

Eine Funktion ist eine konstante Ausdrucksfunktion, wenn:

Sie einen Wert zurückgibt (der Typ "void" ist nicht zulässig)
Der Funktionsrumpf aus einer einzelnen Anweisung besteht, nämlich der Rückgabeanweisung return expr;
Sie mit dem Schlüsselwort constexpr deklariert ist.

Eine Variable oder ein Daten-Member ist ein konstanter Ausdruckswert, wenn:

Er mit dem Schlüsselwort constexpr deklariert ist.
Die Variable oder der Daten-Member mit einem konstanten Ausdruck oder einem R-Wert initialisiert ist, der sich aus einem Konstruktor mit einem konstanten Ausdruck und aus Argumenten mit konstanten Ausdrücken zusammensetzt.

Ein Konstruktor ist ein konstanter Ausdruckskonstruktor, wenn:

Er mit dem Schlüsselwort constexpr deklariert ist.
Sich der Teil mit der Member-Initialisierung nur auf potenzielle konstante Ausdrücke bezieht.
Sein Rumpf leer ist.

Generalisierte konstante Ausdrücke – Beispiel

Das folgende Beispiel enthält eine constexpr-Funktion, eine constexpr-Variable und einen constexpr-Konstruktor:

constexpr int add(int x, int y) {
        return x + y;
}
constexpr double var = 2 * add(3, 4);

class A {
        constexpr A(int newA, int newB) : a(newA), b(newB) {
        }

private:
        int a;
        int b;
};

Ausrichtungsunterstützung

Im C++11-Standard werden die Standardsprache und -bibliothek durch ausrichtungsbezogene Features erweitert.

Zu diesen Ausrichtungs-Features gehören:

Der Ausrichtungsspezifizierer (alignas) für Deklarationen
Der Ausdruck alignof zum Abrufen der Ausrichtungsanforderungen für einen Typ
Die Ausrichtungsarithmetik durch Bibliotheksunterstützung
Die Standardfunktion (std::align) zur Zeigerausrichtung zur Laufzeit

Weitere Informationen zu diesem Feature finden Sie unter Alignment support Proposal document (EN).

Delegierende Konstruktoren

C++11 führt delegierende Konstruktoren ein. Das bedeutet, dass Klassenkonstruktoren in anderen Konstruktoren derselben Klasse aufgerufen werden können.

Dieses Feature ermöglicht es Programmierern, mit weniger Code mehr zu erreichen.

Weitere Informationen zu diesem Feature finden Sie unter Delegating constructors Proposal document (EN).

Delegierende Konstruktoren – Beispiel

Das folgende Beispiel zeigt die Verwendung von delegierenden Konstruktoren:

class B {
        B(int newA) : a(newA) { /* other initializations */
        }

public:
        B() : B(15) { /* other initializations */
        }

public:
        int a;
};

Explizite Konvertierungsoperatoren

In C++11 arbeiten explizit qualifizierte Konvertierungsfunktionen im selben Kontext wie explizit qualifizierte Konstruktoren und erzeugen Diagnosen in denselben Kontexten wie Konstruktoren.

Dies erfolgt zur Vermeidung von Situationen, in denen der Compiler ohne Warnung Code akzeptiert, der semantisch nicht korrekt ist.

Weitere Informationen zu diesen Features finden Sie unter Explicit conversion operators Proposal document (EN).

Neue Zeichentypen

C++11 führt neue Zeichentypen zur Bearbeitung von Unicode-Zeichen-Strings ein.

Weitere Informationen zu diesem Feature finden Sie unter Unicode-Zeichentypen und Literale (C++11).

Unicode-String-Literale

C++11 führt neue Zeichentypen zur Bearbeitung von Unicode-String-Literalen ein.

Weitere Informationen zu diesem Feature finden Sie unter Unicode-Zeichentypen und Literale (C++11).

Roh-String-Literale

Universelle Zeichennamen in Literalen

Damit C++-Code weniger plattformabhängig ist, wurden in C++11 die Verbote bezüglich universeller Zeichennamen in Steuerelementen und grundlegendem Quellcode in Zeichen- und String-Literalen aufgehoben. Verbote für Surrogatwerte in allen universellen Zeichennamen wurden hinzugefügt.

Weitere Informationen zu diesem Feature finden Sie unter Universal character names in literals Proposal document (EN).

Benutzerdefinierte Literale

C++11 führt neue Formen von Literalen mit geänderter Syntax und Semantik ein, um benutzerdefinierte Literale zu ermöglichen.

Mit benutzerdefinierten Literalen können benutzerdefinierte Klassen eine neue Syntax für Literale bereitstellen.

Weitere Informationen zu diesem Feature finden Sie unter User-defined literals Proposal document (EN).

Standard-Layout-Typen

C++11 trennt triviale, spezielle Member-Anforderungen von Layout-Anforderungen, um eine Bereinigungsspezifikation zu erstellen.

POD-Typen (Plain Old Data) werden jetzt in Bezug auf zwei neue Kategorien definiert: triviale Typen und Standard-Layout-Typen. In C++11 können Standard-Layout-Typen Basisklassen haben. Die Basisklassen dürfen aber keine virtuellen Member oder virtuelle Basisklassen haben. Zudem dürfen Standard-Layout-Typen die Zugriffskontrolle haben.

Weitere Informationen zu diesem Feature finden Sie unter Standard Layout Types Proposal document (EN).

Standardmäßig zu verwendende Funktionen

Eine standardmäßig zu verwendende Funktion enthält =default; in ihrem Prototyp. Diese Konstruktion gibt an, dass die Standarddefinition der Funktion verwendet werden soll.

Standardmäßig zu verwendende Funktionen sind ein C++11-spezifisches Feature.

Weitere Informationen zu diesem Feature finden Sie unter Defaulted functions Proposal document (EN).

Standardmäßig zu verwendende Funktionen – Beispiel

class A {
        A() = default;                    // OK
        A& operator = (A & a) = default;  // OK
        void f() = default;               // ill-formed, only special member function may be defaulted
};

Gelöschte Funktionen

Eine gelöschte Funktion enthält =delete; in ihrem Prototyp. Diese in C++11 eingeführte Konstruktion gibt an, dass die Funktion nicht verwendet werden darf.

Mit dieser Konstruktion kann die Verwendung von Standardsprach-Features (wie Standardkonstruktoren oder Standardoperatoren) oder problematischen Konvertierungen verhindert werden.

Weitere Informationen zu diesem Feature finden Sie unter Deleted functions Proposal document (EN).

Gelöschte Funktionen – Beispiel

class A {
        A() = delete;
        A& operator = (A & a) = delete;
};

Erweiterte friend-Deklarationen

C++11 erweitert die aktuelle Sprache um die Unterstützung eines größeren Bereichs von friend-Deklarationen.

Weitere Informationen zu diesem Feature finden Sie unter Extended friend declarations Proposal document (EN).

Erweiterung von sizeof

C++11 erweitert die Funktionalität von sizeof, damit Klassen-Member auch dann als Parameter dienen können, wenn kein Objekt instantiiert wurde.

Weitere Informationen zu diesem Feature finden Sie unter Extending sizeof Proposal document (EN).

Erweiterung von sizeof – Beispiel

Der folgende Code zeigt ein einfaches Beispiel für die erweiterte Verwendung von sizeof.

#pragma hdrstop
#pragma argsused

#include <tchar.h>
#include <stdio.h>

class A {
public:
        int a;
};

int _tmain(int argc, _TCHAR* argv[]) {
        // no object of type A has been instantiated
        int c = sizeof(A::a);
        // well-formed
        return 0;
}

Inline-Namespaces

Der C++11-Standard lässt das Schlüsselwort inline in einer namespace-definition zu. Und zwar, um anzugeben, dass Member des Namespace so definiert und spezialisiert werden können, als ob sie tatsächlich zu dem umgebenden Namespace gehörten.

Diese Konstruktion wird als Inline-Namespace bezeichnet und behebt das Problem, bei dem Templates nur in ihrem tatsächlichen Namespace und nicht in dem Namespace, in den sie importiert wurden, spezialisiert werden konnten.

Weitere Informationen zu diesem Feature finden Sie unter Inline namespaces Proposal document (EN).

Uneingeschränkte Varianten

Im C++11-Standard wurden die Beschränkungen hinsichtlich von Membern von Varianten (Unions) gelockert. In durch Clang erweiterten C++-Compilern können daher alle Typen außer Verweistypen Member von Varianten (Unions) sein.

Weitere Informationen zu diesem Feature finden Sie unter Unrestricted unions Proposal document (EN).

Lokale und unbenannte Typen als Template-Argumente

Der C++11-Standard lässt die Verwendung lokaler und unbenannter Typen als Template-Argumente zu.

Weitere Informationen zu diesem Feature finden Sie unter Local and unnamed types as template arguments Proposal document (EN).

Bereichsbasiertes for

Das Feature "Bereichsbasiertes for" wurde im C++11-Standard eingeführt.

In durch Clang erweiterten C++-Compilern können Sie for-Schleifen erstellen, die eine Liste oder ein Array durchlaufen, ohne den Anfang oder das Ende zu berechnen oder einen Iterator zu verwenden.

Das folgende Beispiel zeigt die Syntax für das bereichsbasierte for für einen String:

UnicodeString string("C++11");
for (auto character : string) {
    std::wcout << character;		
}

Explizite virtuelle Überschreibungen

In Bezug auf virtuelle Überschreibungen wurden in C++11 die Regeln eher gestrafft, damit häufig auftretende Probleme gefunden werden.

Um dieses Ziel zu erreichen, führt C++11 zwei neue kontextabhängige Schlüsselwörter ein:

final – gibt an, dass eine Methode nicht überschrieben oder eine Klasse nicht abgeleitet werden kann.
override – gibt an, dass eine Methode eine virtuelle Methode überschreibt, die in einer der übergeordneten Klassen deklariert ist.

Weitere Informationen zu diesem Feature finden Sie unter Explicit virtual overrides Proposal document (EN).

Explizite virtuelle Überschreibungen – Beispiel

struct base {
        virtual void a();
        void b();
        virtual void c() final;
        virtual void d();
};

struct derived : base {
        void a() override; // correct
        void b() override; // error, override can only be used for virtual functions
        void c() override; // error, cannot override a function marked as final
        int d() override; // error, different return type
};

Auslösen von [noexcept] durch Verschiebekonstruktoren

Der C++11-Standard stellt die Alternative std::move_if_noexcept für std::move bereit, um problematische Interaktionen zwischen Verschiebekonstruktoren, Templates und bestimmten Member-Funktionen der Standardbibliothek zu beheben.

std::move_if_noexcept(x) erteilt die Berechtigung x zu verschieben, außer es kann eine Exception ausgelöst werden und der Typ kann kopiert werden.

Weitere Informationen zu diesem Feature finden Sie unter Allowing move constructors to throw Proposal document (EN).

Definieren spezieller Member-Funktionen für das Verschieben

C++11 stellt eine Möglichkeit zur Definition spezieller Member-Funktionen für das Verschieben und Kopieren bereit.

Weitere Informationen zu diesem Feature finden Sie unter Defining move special member functions Proposal document (EN).

"Atomic"-Operationen

C++11 erweitert den Standard um atomic-Typen und -Operationen. Atomic-Typen und -Operationen ermöglichen das Schreiben von Multithread-Anwendungen ohne Verwendung von Sperren.

Weitere Informationen zu diesem Feature finden Sie unter Atomic operations Proposal document (EN).

Starker Vergleich und Austausch

C++11 ermöglicht schwache und starke Vergleichs- und Austauschoperationen.

Vergleichs- und Austauschoperationen sind atomic-Operationen, die in Multithread-Anwendungen für die Synchronisierung eingesetzt werden.

Weitere Informationen zu diesem Feature finden Sie unter Strong Compare and Exchange Proposal document (EN).

Bidirektionale Fences

Ein "Fence" ist eine grundlegende Operation, die das Einhalten der Reihenfolge zwischen vorangehenden Lade- oder Speichervorgängen und nachfolgenden Lade- oder Speichervorgängen durchsetzt. In C++11 wurde die Unterstützung für bidirektionale Fences verbessert.

Weitere Informationen zu diesem Feature finden Sie unter Bidirectional Fences Proposal document (EN).

Weitergeben von Exceptions

Der C++11-Standard ermöglicht die Weitergabe von Exceptions von einem Thread zu einem anderen. Dazu wurden einige Änderungen am <exception>-Header vorgenommen.

Weitere Informationen zu diesem Feature finden Sie unter Propagating exceptions Proposal document (EN).

Zulassen von "Atomics" in Signalbehandlungsroutinen

C++11 lässt die Verwendung von Atomics in Signalbehandlungsroutinen zu.

Weitere Informationen zu diesem Feature finden Sie unter Allow atomics use in signal handlers Proposal document (EN).

Vordefinierter Bezeichner func

Mit diesem Feature werden Funktionsnamen als String-Literale erfasst und Diagnosebibliotheken unterstützt.

Weitere Informationen zu diesem Feature finden Sie unter __func__ predefined identifier Proposal document (EN).

C99-Präprozessor

Im C++11-Standard wird versucht, den Präprozessor und die Übersetzungsphasen von C++ mit C99 neu zu synchronisieren, damit die beiden Standards kompatibler sind.

Unter anderem wurden in den Bereichen vordefinierte Makros, Operator "pragma" und String-Literalverkettungen Änderungen vorgenommen.

Weitere Informationen zu diesem Feature finden Sie unter C99 preprocessor Proposal document (EN).

Typ long long

Um eine größer Kompatibilität mit C99 zu erreichen, wurde im C++11-Standard der integrale Typ long long eingeführt.

Weitere Informationen zu diesem Feature finden Sie unter long long type Proposal document (EN).

Weitere Features

Lambda-Ausdrücke

Siehe auch