Moderne C++-Features, die von durch Clang erweiterte C++-Compiler in RAD Studio unterstützt werden
Nach oben zu Modernes C++
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
- 3.1 Beschreibung der R-Wert-Referenzen
- 3.2 Initialisierung von Klassenobjekten durch R-Werte
- 3.3 Initialisierung von nicht-statischen Daten-Membern
- 3.4 Variadische Templates
- 3.5 Erweitern von Template-Parametern variadischer Templates
- 3.6 Initialisierungslisten
- 3.7 Statische Assertions
- 3.8 Automatisch typisierte Variablen
- 3.9 Deklarierter Typ eines Ausdrucks
- 3.10 Unvollständige Rückgabetypen
- 3.11 Rechte spitze Klammern
- 3.12 Template-Standardargumente für Funktions-Templates
- 3.13 Beheben des SFINAE-Problems bei Ausdrücken
- 3.14 Alias-Templates
- 3.15 Externe Templates
- 3.16 Nullzeigerkonstante
- 3.17 Streng typisierte Aufzählungen
- 3.18 Forward-Deklarationen von Enums
- 3.19 Generalisierte konstante Ausdrücke
- 3.20 Ausrichtungsunterstützung
- 3.21 Delegierende Konstruktoren
- 3.22 Explizite Konvertierungsoperatoren
- 3.23 Neue Zeichentypen
- 3.24 Unicode-String-Literale
- 3.25 Roh-String-Literale
- 3.26 Universelle Zeichennamen in Literalen
- 3.27 Benutzerdefinierte Literale
- 3.28 Standard-Layout-Typen
- 3.29 Standardmäßig zu verwendende Funktionen
- 3.30 Gelöschte Funktionen
- 3.31 Erweiterte friend-Deklarationen
- 3.32 Erweiterung von sizeof
- 3.33 Inline-Namespaces
- 3.34 Uneingeschränkte Varianten
- 3.35 Lokale und unbenannte Typen als Template-Argumente
- 3.36 Bereichsbasiertes for
- 3.37 Explizite virtuelle Überschreibungen
- 3.38 Auslösen von [noexcept] durch Verschiebekonstruktoren
- 3.39 Definieren spezieller Member-Funktionen für das Verschieben
- 3.40 "Atomic"-Operationen
- 3.41 Starker Vergleich und Austausch
- 3.42 Bidirektionale Fences
- 3.43 Weitergeben von Exceptions
- 3.44 Zulassen von "Atomics" in Signalbehandlungsroutinen
- 3.45 Vordefinierter Bezeichner __func__
- 3.46 C99-Präprozessor
- 3.47 Typ long long
- 3.48 Weitere Features
- 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.
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:
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.
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
Siehe auch
- Konformitätsstatus moderner C++-Sprach-Features
- alignof Operator (C++11)
- auto (Schlüsselwort)
- Durch Clang erweiterte C++-Compiler
- Workaround für die C++11-Attribute "deprecated" und "final" (durch Clang erweiterte C++-Compiler)
- Erstellen einer einfachen C++-Anwendung zur Verwendung moderner C++-Features
- Clang support for C++11 (EN)