Zobrazení zdroje stránky C++11

{{Verze jazyka C++}}
[[Soubor:Bjarne-stroustrup.jpg|náhled|Autor jazyka C++ [[Bjarne Stroustrup]] (vlevo) na konferenci CEE-SECR 2010 v [[Moskva|Moskvě]]]]
'''C++11''' (dříve '''C++0x'''<ref name=":0">{{Citace elektronické monografie
 | příjmení = Stroustrup
 | jméno = Bjarne
 | titul = C++11 FAQ
 | url = http://www.stroustrup.com/C++11FAQ.html
 | vydavatel = stroustrup.com
 | datum přístupu = 2014-10-15
 | datum archivace = 2018-10-06
 | url archivu = https://web.archive.org/web/20181006014513/http://www.stroustrup.com/C++11FAQ.html
 | nedostupné = live
 | ref = harv
}}</ref>) je standard [[C++|programovacího jazyka C++]]. Byl schválen organizací ISO dne 12. srpna 2011 a nahrazuje [[C++03]]. Označení navazuje na tradici pojmenovávání verzí jazyka podle roku publikování specifikace. C++11 přidává několik prvků k jádru jazyka a rozšiřuje standardní [[C++]] knihovnu. V září 2011 byl standard publikován jako ISO/IEC 14882:2011.<ref>{{citace elektronické monografie
 | titul = ISO/IEC 14882:2011
 | url = http://www.iso.org/iso/iso_catalogue/catalogue_ics/catalogue_detail_ics.htm?ics1=35&ics2=60&ics3=&csnumber=50372
 | publisher = ISO
 | datum_přístupu = 2011-09-03
}}</ref>

Nejnovějšími standardy jsou postupně [[C++14]], [[C++17]] a [[C++20]], a pracuje se na standardu [[C++23]].<ref>{{Citace elektronického periodika
| titul = cppreference.com
| periodikum = en.cppreference.com
| url = https://en.cppreference.com/w/
| datum přístupu = 2021-09-15
}}</ref><ref>{{Citace elektronického periodika
| titul = Recent milestones: C++17 published, C++20 underway
| periodikum = isocpp.org
| url = https://isocpp.org/std/status
| jazyk = en
| datum přístupu = 2018-07-20
}}</ref>

== Cíle návrhu ==
Komise pro návrh C++11 kladla důraz na:
* zachování stability a [[Zpětná kompatibilita|kompatibility]] se staršími verzemi C++ a [[C (programovací jazyk)|jazykem C]]
* nerozšiřování jádra jazyka (pokud je to možné) – nové vlastnosti přednostně zavádět do standardní knihovny<ref name=":1">{{Citace elektronické monografie
 | titul = C++11 Overview: What specific design goals guided the committee?
 | url = https://isocpp.org/wiki/faq/cpp11#cpp11-specific-goals
 | vydavatel = Standard C++
 | datum přístupu = 2015-09-04
 | datum archivace = 2019-01-31
 | url archivu = https://web.archive.org/web/20190131050050/https://isocpp.org/wiki/faq/cpp11#cpp11-specific-goals
 | nedostupné = live
 | ref = harv
}}</ref>
* zlepšení jazyka C++, aby se usnadnil návrh systémů a knihoven místo zavádění nových vlastností užitečných pouze pro určité aplikace
* zvýšení typové bezpečnosti poskytnutím bezpečnějších alternativ k původním nebezpečným technikám
* zvýšení výkonnosti a zlepšení schopností pracovat přímo s hardwarem
* poskytování vhodných nástrojů pro řešení reálných problémů
* usnadnění učení a vyučování jazyku C++ bez odstraňování užitečných vlastností používaných zkušenými programátory

Významná je pozornost věnovaná začátečníkům, protože velká část programátorů jimi navždy zůstane, a protože si mnoho začátečníků nikdy nerozšíří své znalosti nad rámec těch aspektů jazyka, na které se specializují.<ref name=":0" /><ref name=":1" />

== Rozšíření jádra jazyka C++ ==
Jednou z funkcí komise C++ je vývoj jádra jazyka. K oblastem jádra jazyka, které byly výrazně vylepšeny, patří podpora [[Vlákno (informatika)|multithreadingu]], podpora [[Generické programování|generického programování]], uniformní inicializace a zvyšování výkonnosti.

=== Rozšíření jádra pro rychlejší běh ===
==== Reference jako r-hodnota a move konstruktor ====
Umožňuje použít referenci na objekt jako r-hodnotu. R-hodnota je dočasná konstanta, do které nelze nijak zapisovat.
<syntaxhighlight lang="cpp">
int a;
a = 5 + 10 // (5 + 10) je r-hodnota
(5 + 10) = a; // nelze přiřadit hodnotu r-hodnotě.

int& b = 10; // nelze, nemůže existovat nekonstantní reference na r-hodnotu, konstanta není uložená v paměti, ale dosazena překladačem
const int& b = 10; // lze, za b se vždy dosadí 10
int&& b = 10; // lze, uloží se do paměti jako dočasná proměnná, inicializuje se na hodnotu 10
</syntaxhighlight>

Move konstruktor lze využít pro přesun zdrojů z jedné třídy do druhé bez alokace a dealokace paměti. C++11 zavádí operátor && jako referenci na r-hodnotu. Move konstruktor je definován jako <code>Trida(Trida&& trida)</code>, a zavolá se při konstrukci objektu z reference na objekt, který je r-hodnotou.
<syntaxhighlight lang="cpp">
class Array {
    int* pole;
    size_t s;

public:
    // Konstruktor
    Array(size_t s) : s(s) {
        pole = new int[s];
    }

    // Kopírovací konstruktor
    Array(const Tr1& par) {
        pole = new int[s];
        memcpy(pole, par.pole, sizeof(int) * s);
    }

    // Move konstruktor
    Array(Tr1&& par) {
        pole = par.pole;
        s = par.s;
        par.pole = 0;
        par.s = 0;
    }

    ~Array() {
        delete[] pole;
    }
};

Array pole1(100); // Zavolá standardní konstruktor
Array pole2(static_cast<Array&&>(pole1)); // Přetypuje pole1 na referenci na r-hodnotu, a zavolá move konstruktor
// pole2 je stejné jako bylo pole1 a pole1 je prázdné
</syntaxhighlight>

==== constexpr – Obecné konstantní výrazy ====
C++11 zavádí klíčové slovo <code>constexpr</code>, které u funkce nebo objektu vynutí, že bude vyhodnocena (objekt konstruován) v době kompilace.
<syntaxhighlight lang="cpp">
int get_five() {
    return 5;
}

int some_value[get_five() + 7]; // Nelze použít, get_five() není konstantní výraz

enum {
    five = get_five(); // Nelze použít, get_five() není konstantní vyraz
};

constexpr int get_five() {
    return 5;
}

int some_value[get_five() + 7];

enum {
    five = get_five();
};
</syntaxhighlight>

==== Nová definice POD ====
Třída nebo struktura v C++03 musí splňovat několik podmínek, aby byla považována za [[plain old data]] (POD) typ. Typy, které této definici vyhovují, vytvářejí rozvržení objektů, které je kompatibilní s jazykem C, a je možné je inicializovat staticky. Norma C++03 má omezení na to, jaké typy jsou kompatibilní s jazykem C a které lze staticky inicializovat, protože neexistuje žádný technický důvod, aby překladač nemohl program přijmout; pokud by někdo úmyslně vytvořil C++03 POD typ a přidal nevirtuální členskou funkci, tento typ by již nebyl POD typem, nemohl by být staticky inicializován, a nebyl by kompatibilní s jazykem C, i kdyby nedošlo ke změně rozložení paměti.

C++11 uvolnilo několik pravidel pro POD a rozdělilo koncept POD na dva samostatné koncepty: ''triviální'' a ''se standardní strukturou''.

Typ, který je ''triviální'', může být staticky inicializován. To znamená, že jeho obsah lze kopírovat funkcí <code>memcpy</code> a není nutné používat kopírovací konstruktor. Životnost ''triviálního'' typu začíná, když je definován jeho úložný prostor, a ne když končí konstruktor.

Třída nebo struktura je triviální, pokud:

# má triviální implicitní konstruktor; konstruktor může používat [[#Explicitně implicitní speciální členská funkce|implicitní konstruktoru syntax]] (<code>SomeConstructor() = default;</code>).
# má triviální kopírovací a přesunové konstruktory, který může použít implicitní syntax.
# má triviální kopírovací a přesunové operátory přiřazení, které mohou použít implicitní syntax.
# má triviální destruktor, který nesmí být virtuální.

Konstruktory jsou triviální, pouze pokud třída nemá žádné virtuální členské funkce a žádné virtuální základní třídy. Operace kopírování a přesunu také vyžadují, aby všechny nestatické datové členy byly triviální.

Že typ má ''standardní strukturu'', znamená, že uspořádává a pakuje své členy způsobem, které je kompatibilní s jazykem C. Třída nebo struktura je standardní strukturou, pokud:

# nemá žádné [[virtuální funkce]]
# nemá žádné virtuální základní třídy
# všechny jeho nestatické datové členy mají stejné řízení přístupu (public, private, protected)
# všechno jeho nestatické datové členy, včetně libovolný v jeho základní třídy, jsou v stejný jeden třída v hierarchie
# výše uvedená pravidla také platí pro všechny bázové třídy a všechny nestatické datové členy v hierarchii tříd
# nemá žádný základní třídy stejného typu jako první definovaný nestatický datový člen

Třída, struktura nebo union se považuje za POD, pokud je triviální, má standardní strukturu, a veškeré jeho nestatické datové členy a základní třídy jsou PODy.

Díky oddělení těchto konceptů je možné se jednoho vzdát, aniž by byl porušen druhý. Třída se složitými přesunovými a kopírovací konstruktory nemusí být triviální, ale pokud má standardní strukturu, může spolupracovat s jazykem C. Podobně třída s veřejnými a soukromými nestatickými datovými členy nebude mít standardní strukturu, ale může být triviální, a pak ji lze kopírovat pomocí <code>memcpy</code>.

=== Rozšíření jádra pro rychlejší kompilaci ===
==== Externí šablona ====
V C++03 musí překladač instanciovat šablonu vždy, když se v kompilační jednotce objeví plně specifikovaná šablona, např.:

<syntaxhighlight lang="cpp">
template class std::vector<myclass>; </syntaxhighlight>

Pokud je šablona instanciována se stejnými typy v mnoha kompilačních jednotkách, může to výrazně prodloužit trvání překladu. V C++03 tomu nelze zabránit, ale C++11 zavádí externí deklarace šablon podobné externím deklaracím dat. Používají deklarátor <code>extern</code>:

<syntaxhighlight lang="cpp">
extern template class std::vector<myclass>; </syntaxhighlight>

čímž říká překladači, aby v této kompilační jednotce instanciaci šablony ''neprováděl''.

=== Rozšíření jádra pro lepší použití jazyka ===
==== Seznamy inicializátorů ====
C++11 rozšiřuje statickou inicializaci pole nebo struktury známou z C. Pomocí <code>std::initializer_list<></code> umožňuje konstruktoru předat pole inicializačních parametrů uzavřených v {}.

<syntaxhighlight lang="cpp">
// inicializace v C
int pole[] = {10, 10}; // inicializace pole

typedef struct {
    int a;
    int b;
} Struktura;

Struktura strukt = {10, 10}; // inicializace struktury

// inicializace v C++11
class Trida {
public:
    Trida(int par);
};

Trida pole[] = {10, 10}; // inicializace pole tříd

class Trida {
public:
    Trida(std::initializer_list<int> list);
};

Trida pole = {1, 2}; // inicializace třídy
</syntaxhighlight>

==== Typová inference ====
C++11 zavádí dvě nové metody, jak deklarovat proměnné. Klíčové slovo <code>auto</code> doplní typ proměnné automaticky podle přiřazované hodnoty. Funkce <code>decltype(výraz)</code> vrací typ parametru.
<syntaxhighlight lang="cpp">
auto i = 15; // i bude int;
decltype(i) j; // j bude int;
</syntaxhighlight>

Výhodu přináší u složitých typů, zkracuje zápis.
<syntaxhighlight lang="cpp">
// C++03
for(std::vector<int>::const_iterator it = data.cbegin(); it != data.cend(); ++it);

// C++11
for(auto it = data.cbegin(); it != data.cend(); ++it);
</syntaxhighlight>

==== For cyklus ====
Rozšiřuje o novou definici cyklu for. Tento cyklus je známý z jiných jazyků jako cyklus [[Cyklus foreach|foreach]].
<syntaxhighlight lang="cpp">
int pole[10];

for(int& i : pole) {

}
</syntaxhighlight>Tento cyklus lze také použít pro kontejnery, které poskytují metody begin a end.

==== Lambda funkce ====
C++11 zavádí [[anonymní funkce]] (lambda funkce). Lambda funkce umožňuje deklarovat i definovat dočasnou funkci (například jako parametr funkce nebo uvnitř jiné funkce).
<syntaxhighlight lang="cpp">
[externí_proměnné](parametry)->návratový_typ { tělo funkce; }
</syntaxhighlight>

V hranatých závorkách lze předat proměnné z rozsahu platnosti, ve kterém je funkce definovaná. Lze předat všechny, nebo jen výčet a je možné je předat hodnotou nebo referencí.
<syntaxhighlight lang="cpp">
[] // funkce nemá přístup k externím proměnným
[x, &y] // k proměnné x lze ve funkci přistupovat jako k hodnotě, k y jako k referenci
[&] // všechny proměnné jsou předány referencí
[=] // všechny proměnné jsou předány hodnotou
[&, x] // x je předáno hodnotou, všechny ostatní referencí
</syntaxhighlight>

Příklad lambda funkce:
<syntaxhighlight lang="cpp">
[](int x, int y) { return x + y; } // Návratový typ je implicitní, funkce nevidí žádné proměnné mimo rozsah své platnosti

int a = 10;
[&](int x, int y)->int { return x + y + a; } // Návratový typ je explicitní, funkce má přístup ke všem proměnným z rozsahu platnosti
                                             // ve které je definována, proměnné jsou předány referencí
[=](int x, int y)->int { return x + y + a; } // proměnné jsou předány hodnotou
</syntaxhighlight>

==== Aliasy na jmenné prostory ====
<syntaxhighlight lang="c++">
namespace ab
{
    int zdvojnasob(int x)
    {
        return x*2;
    }
}
namespace x=ab;
x::zdvojnasob(5);//To samé jako ab::zdvojnasob(5)
</syntaxhighlight>

==== Nová syntaxe typových aliasů ====
<syntaxhighlight lang="c++">
//C++98
typedef int my_type;
//C++11
typedef int my_type;//Zpětná kompatibilita
using my_type=int;//Nová syntaxe

//Toto pomocí typedef nelze:
template<typename T>using ptr=T*;
</syntaxhighlight>

==== {{Kotva|trailing-return-type}} Alternativní syntaxe funkcí ====
Syntaxe deklarací funkcí ve standardním [[C (programovací jazyk)|jazyce C]] byla pro tento jazyk naprosto dostatečná. Protože se jazyk C++ vyvinul z jazyka C, udržoval základní syntaxi a rozšířil ji, kde to bylo potřebné. Jak se jazyk C++ zesložiťoval, byl vystaven několika limitům, zvláště týkajících se deklarace šablon funkcí. Například v C++03 není toto možné:

<syntaxhighlight lang="cpp">
template<classLhs, třída Rhs>
  Ret adding_func(const Lhs &lhs, const Rhs &rhs) {return lhs + rhs;} //Ret musí mít typ jako lhs+rhs
</syntaxhighlight>

Typ <code>Ret</code> je cokoli, co vznikne sečtením typů <code>Lhs</code> a <code>Rhs</code>. Dokonce ani s výše uvedenou funkčností <code>decltype</code> je v C++11 následující zápis chybný:

<syntaxhighlight lang="cpp">
template<classLhs, třída Rhs>
  decltype(lhs+rhs) adding_func(const Lhs &lhs, const Rhs &rhs) {return lhs + rhs;} // V C++11 není dovoleno
</syntaxhighlight>

Tato konstrukce není v C++ povolena, protože <code>lhs</code> a <code>rhs</code> zatím nebyly definovány; identifikátory nejsou platné, dokud analyzátor neprovede analýzu zbytku prototypu funkce.

Proto C++11 umožňuje zadat typ návratové hodnoty funkce až za seznamem parametrů a symbolem <code>-></code>:<ref>{{Citace elektronické monografie
 | url = http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1978.pdf
 | titul = Decltype (revision 5)
 | datum přístupu = 2022-02-16
 | datum archivace = 2022-02-14
 | url archivu = https://web.archive.org/web/20220214133743/http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2006/n1978.pdf
 | nedostupné = live
 | ref = harv
}}</ref>

<syntaxhighlight lang="cpp">
template<classLhs, třída Rhs>
  auto adding_func(const Lhs &lhs, const Rhs &rhs) -> decltype(lhs+rhs) {return lhs + rhs;}
</syntaxhighlight>

Tuto syntaxi lze používat i pro jednodušší deklarace a definice funkcí:

<syntaxhighlight lang="cpp">
struct SomeStruct
{
    auto func_name(int x, int y) -> int;
};

auto SomeStruct::func_name(int x, int y) -> int
{
    return x + y;
}
</syntaxhighlight>

Klíčové slovo <code>auto</code> je v tomto případě pouze syntaktickou záležitostí a neznamená automatické vyvozování typu. Od C++14 je možné návratový typ funkce za seznamem parametrů zcela vypustit a překladač si jej odvodí sám.<ref>{{Citace elektronické monografie
 | url = http://en.cppreference.com/w/cpp/language/auto
 | titul = auto specifier (since C++11) - cppreference.com
 | vydavatel = en.cppreference.com
 | datum přístupu = 2016-10-18
 | datum archivace = 2016-10-20
 | url archivu = https://web.archive.org/web/20161020050910/http://en.cppreference.com/w/cpp/language/auto
 | nedostupné = live
 | ref = harv
}}</ref>

==== Zlepšení konstrukce objektů ====
V C++03 není dovoleno konstruktorům třídy volat jiné konstruktory v seznamu inicializátorů této třídy. Každý konstruktor musí vytvořit veškeré členy své třídy sám nebo zavolat společnou členskou funkci, jako např.:

<syntaxhighlight lang="cpp">
class SomeType
{
public:
    SomeType(int new_number)
    {
        Construct(new_number);
    }

    SomeType()
    {
        Construct(42);
    }

private:
    void Construct(int new_number)
    {
        number = new_number;
    }

    int number;
};
</syntaxhighlight>

Konstruktory bázových tříd nemohou být přímo zpřístupněny odvozeným třídám; každá odvozená třída musí implementovat vlastní konstruktory, i když by stačil konstruktor základní třídy. Nekonstantní datové členy třídy nemohou být inicializovány v místě své deklarace, ale pouze v konstruktoru.

C++11 poskytuje řešení všech těchto problémů:

C++11 umožňuje, aby konstruktory volaly jiné konstruktory (což se nazývá [[delegace (programování)|delegace]]). To umožňuje, aby konstruktory využívaly chování jiných konstruktorů s minimem přidaného kódu. Delegace jsou dostupné v jiných jazycích, např. v [[Java (programovací jazyk)|Javě]] nebo v [[Objective-C]].

V C++11 lze místo výše uvedeného kódu definujícího jeden konstruktor s parametrem a druhý bez parametru napsat:

<syntaxhighlight lang="cpp">
class SomeType
{
    int number;

public:
    SomeType(int new_number) : number(new_number) {}
    SomeType() : SomeType(42) {}
};
</syntaxhighlight>

Stejného efektu by bylo možné dosáhnout tím, že by <code>new_number</code> bylo implicitním parametrem. Nová syntaxe však umožňuje, aby implicitní hodnota (42) byla vyjádřena v implementaci místo v rozhraní – což je výhodné pro údržbu knihoven, protože implicitní hodnoty funkčních parametrů jsou „zapečené“ v místech volání, zatímco delegování konstruktoru umožňuje změnit hodnotu bez nového překladu kódu používajícího knihovnu.

Delegace konstruktorů přináší určitý problém: zatímco v C++03 je na konci provádění libovolného konstruktoru objekt úplně vytvořen, v C++11 je objekt vytvořen, až když doběhnou ''všechny'' konstruktory. Protože je povoleno provádět více konstruktorů, každý delegující konstruktor bude pracovat na plně zkonstruovaném objektu pouze svého typu. Konstruktory odvozených tříd se budou provádět až po dokončení všech delegací v jejich základních třídách.

Pro konstruktory základních tříd umožňuje C++11 třídě určit, že konstruktory základní třída budou zděděny. Překladač C++11 tedy vygeneruje kód, který provede dědění a předání odvozené třídy základní třídě. Jde o přístup typu „všechno nebo nic“: buď budou předány všechny konstruktory dané základní třídy nebo žádný z nich. Také zděděný konstruktor bude [[Rezoluce jmen#Zastiňování jmen|zastíněn]], pokud se shoduje se signaturou konstruktoru odvozené třídy, a existují omezení pro vícenásobnou dědičnost: konstruktory třídy nelze [[Vícenásobná dědičnost|dědit ze dvou tříd]], které používají konstruktory se stejnou signaturou.

Syntaxe je následující:

<syntaxhighlight lang="cpp">
class BaseClass
{
public:
    BaseClass(int value);
};

class DerivedClass : public BaseClass
{
public:
    using BaseClass::BaseClass;
};
</syntaxhighlight>

C++11 dovoluje tuto syntaxi pro inicializaci členů:

<syntaxhighlight lang="cpp">
class SomeClass
{
public:
    SomeClass() {}
    explicit SomeClass(int new_value) : value(new_value) {}

private:
    int value = 5;
};
</syntaxhighlight>

Libovolný konstruktor této třídy bude inicializovat <code>value</code> na 5, pokud konstruktor sám nepředefinuje inicializaci. Proto výše uvedený prázdný konstruktor bude inicializovat <code>value</code> jak uvádí definice třídy, ale konstruktor s parametrem typu <code>int</code> bude inicializovat <code>value</code> na hodnotu tohoto parametru.

Může také místo inicializace přiřazením uvedené výše použít konstruktor nebo uniformní inicializaci.

==== Explicitní předefinování a final ====
V C++03 může programátor omylem vytvořit novou virtuální funkci, když chtěl předefinovat funkci základní třídy. Například:

<syntaxhighlight lang="cpp">
struct Base
{
    virtual void some_func(float);
};

struct Derived : Base
{
    virtual void some_func(int);
};
</syntaxhighlight>

Předpokládáme, že <code Derived::some_func</code> měla nahradit metodu základní třídy. Ale protože má jinou [[Typová signatura|signaturu]], vytvoří další virtuální funkci. To je častý problém, ke kterému dochází zvláště tehdy, když uživatel chce modifikovat základní třídu.

C++11 umožňuje tento problém řešit takto:

<syntaxhighlight lang="cpp">
struct Base
{
    virtual void some_func(float);
};

struct Derived : Base
{
    virtual void some_func(int) override; // chyba - nepředefinovává metodu základní třídy
};
</syntaxhighlight>

Speciální identifikátor <code>override</code> znamená, že překladač bude kontrolovat základní třídu nebo třídy, zda existuje virtuální funkce přesně s touto signaturou. A pokud neexistuje, překladač oznámí chybu.

C++11 také umožňuje zabránit dědění z třídy nebo jednoduše zabránit předefinování metody v odvozených třídách. K tomuto účelu slouží speciální identifikátor <code>final</code>. Například:

<syntaxhighlight lang="cpp">
struct Base1 final { };

struct Derived1 : Base1 { }; // chybné, protože třída Base1 byla označena jako final
</syntaxhighlight>

<syntaxhighlight lang="cpp">
struct Base2
{
    virtual void f() final;
};

struct Derived2 : Base2
{
    void f(); // chybné, protože virtuální funkce Base2::f byla označena jako final
};
</syntaxhighlight>

V tomto příkladě příkaz <code>virtual void f() final;</code> deklaruje novou virtuální funkci, a zároveň brání tomu, aby ji odvozená třída předefinovala. Také způsobuje, že odvozené třídy nemohou používat funkce s tímto jménem a kombinací parametrů.

Ani <code>override</code> ani <code>final</code> nejsou klíčová slova. Technicky to jsou identifikátory atributů deklarátorů:
* speciální význam jako atributy mají pouze v těchto specifických koncových kontextech (po všech specifikátorech typu, přístupu, deklaracích členů (typů struktura, třída nebo výčet) a specifikátorech deklarátorů, ale před inicializací nebo implementací kódu každého deklarátoru v seznamu deklarátorů oddělených čárkou);
* nemění deklarovanou typovou signaturu a nedeklarují ani nepředefinovávají žádný nový identifikátor v jakémkoli rozsahu platnosti;
* rozpoznané a přijaté atributy deklarátorů mohou být v budoucí verzi C++ rozšířeny (některá rozšíření pro konkrétní překladače již rozpoznávají další atributy deklarátorů pro volby generování kódu nebo optimalizační nápovědy pro překladač nebo pro generování dodatečných dat do přeloženého kódu, která jsou určena pro debuggery, linkery, a nasazení přeloženého kódu nebo pro poskytování přídavných atributů datové bezpečnosti specifických pro daný systém nebo pro zlepšení schopností [[reflexe (programování)|reflexí]] v době běhu nebo pro poskytnutí dalších informací pro vázání pro interoperabilitu s jiný programovacími jazyky a běhovými systémy; tato rozšíření mohou využívat parametry zapsané v závorkách po identifikátoru atributu deklarátoru; aby tato rozšíření specifická pro určitý překladač vyhovovala normě ANSI, musí jejich jména začínat dvojitým podtržítkem).
* na libovolném jiném místě mohou být tyto identifikátory použity pro nové deklarace (a pozdější použití, pokud jsou dostupné).

==== Konstanta a typ nulového ukazatele ====
V této části každý výskyt <code>0</code> je míněn jako „konstantní výraz, který je typu int, a vyhodnotí se na hodnotu <code>0</code>“. Ve skutečnosti tento konstantní výraz může být libovolného celočíselného typu.

Od počátků jazyka C v roce 1972 měla konstanta <code>[[Nula|0]]</code> dvojí roli celého číslo a [[Nulový ukazatel|nulového ukazatele]]. Nejednoznačnost spjatá s dvojím významem hodnoty <code>0</code> se v jazyce C řešila makrem preprocesoru <code>NULL</code>, které se obvykle expanduje buď na <code>((void*)0)</code> nebo na <code>0</code>. C++ zakazuje implicitní konverze hodnot typu <code>void *</code> na jiné typy ukazatelů, čímž odstraňuje výhodu změny typu <code>0</code> na <code>void *</code>. V důsledku toho je pouze <code>0</code> povolena jako konstanta nulového ukazatele. To jde špatně dohromady s [[přetěžování]]m:

<syntaxhighlight lang="cpp">
void foo(char *);
void foo(int);
</syntaxhighlight>

Pokud <code>NULL</code> je definované jako <code>0</code> (což v C++ obvykle je), příkaz <code>foo(NULL);</code> vyvolá <code>foo(int)</code>, což je téměř určitě něco, co programátor nechtěl, a co naznačuje povrchní čtení kódu.

C++11 opravuje tento problém definováním nového klíčového slova <code>nullptr</code>, které slouží jako konstanta pro nulový ukazatel. Tato konstanta je typu <code>nullptr_t</code>, který lze implicitně zkonvertovat na libovolný typ ukazatele nebo ukazatele na člen, a porovnávat s libovolným ukazatelem. <code>nullptr</code> nelze implicitně zkonvertovat na celočíselný typ ani jej s celočíselnými typy porovnávat, kromě typu <code>bool</code>. Zatímco původní návrh uváděl, že rvalue typu <code>nullptr_t</code> nesmí být možné zkonvertovat na <code>bool</code>, pracovní skupina pro jádro jazyka rozhodla, že takové konverze jsou žádoucí pro konzistenci s normálními typy ukazatel. Navrhované změny znění byly v červnu 2008 jednomyslně odhlasovány do pracovního dokumentu.{{Ref|n2697}} Podobný návrh byl předložen také pracovní skupině pro normu jazyka C a byl přijat pro začlenění do [[C23 (C standardní revize)|normy C23]].<ref>{{Citace periodika
 | příjmení = Gustedt
 | jméno = Jens
 | datum = 2019-07-09
 | titul = Introduce the nullptr constant - v1
 | url = http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2394.pdf
 | periodikum = ISO JTC1/SC22/WG14 Document Register
 | vydavatel = International Organization for Standardization
 | via = open-std.org
 | datum přístupu = 2020-04-19
 | datum archivace = 2020-07-27
 | url archivu = https://web.archive.org/web/20200727055706/http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2394.pdf
 | nedostupné = live
 | ref = harv
}}</ref>

Kvůli zpětné kompatibilitě zůstává <code>0</code> platnou konstantou pro nulový ukazatel.

<syntaxhighlight lang="cpp">
char *pc = nullptr; // OK
int *pi = nullptr; // OK
bool b = nullptr; // OK. b je nepravdivé.
int i = nullptr; // chyba

foo(nullptr); // volá foo(nullptr_t), ne foo(int);
/*
  Všimněte si, že foo(nullptr_t) skutečně volá foo(char *) ve výše uvedeném příkladě použitím implicitní konverze,
  pouze pokud žádné jiné funkce nepřetěžují kompatibilní typy ukazatele v rozsahu platnosti.
  Pokud existuje více přetížení, rezoluce selže kvůli nejednoznačnosti,
  pokud neexistuje explicitní deklarace foo(nullptr_t).

  V hlavičkových souborech pro standardní typy pro C++11 musí typ nullptr_t být deklarován jako:
      typedef decltype(nullptr) nullptr_t;
  ne jako:
      typedef int nullptr_t; // předchozí verze C++, ve kterých musí být NULL být definováno jako 0
      typedef void *nullptr_t; // ANSI C, které definuje NULL jako ((void*)0)
* /
</syntaxhighlight>

==== Silně typované výčtové typy ====
V C++03 nejsou výčtové typy typově bezpečné. Efektivně to jsou celá čísla, i když jsou výčtové typy různé. To umožňuje porovnávat výčtové hodnoty různých výčtových typů. Jedinou bezpečností, kterou C++03 poskytuje, je, že celá čísla nebo hodnoty jednoho výčtového typu se implicitně nekonvertují na jiný výčtový typ. Podkladové celočíselné typy jsou implementačně závislé; proto je kód, které závisí na velikosti výčtových typů, nepřenositelný. Rozsah platnosti výčtových hodnot je obklopující rozsah platnosti. Proto dva různé výčtové typy ve stejném rozsahu platnosti nemohou mít stejná jména hodnot.

C++11 umožňuje speciální klasifikaci výčtových typů bez výše uvedených problémů. Používá deklaraci pomocí <code>enum class</code> (lze používat i <code>enum struct</code>):

<syntaxhighlight lang="cpp">
enum class Enumeration
{
    Val1,
    Val2,
    Val3 = 100,
    Val4 // = 101
};
</syntaxhighlight>

Tento výčtový typ je typově bezpečný. Hodnoty enum class se implicitně nekonvertují na celá čísla. Proto je nelze porovnávat s celými čísly (výraz <code>Enumeration::Val4 == 101</code> způsobí chybu při překladu).

Podkladový typ těchto výčtových tříd je vždy známý. Implicitní typ je <code>int</code>, ale může být předefinován na jiný celočíselný typ, jak je vidět v tomto příkladě:

<syntaxhighlight lang="cpp">
enum class Enum2 : unsigned int {Val1, Val2};
</syntaxhighlight>

Výčtové hodnoty starých výčtových typů mají rozsah platnosti rovný obklopujícímu rozsahu platnosti. Výčtové hodnoty nových výčtových typů mají rozsah platnosti daný výčtovou třídou. Ve výše uvedeném příkladě <code>Val1</code> není definováno, ale <code>Enum2::Val1</code> ano.

Existuje také přechodová syntaxe umožňující výčtovým hodnotám starého stylu poskytovat explicitní používání rozsahů platnosti a definice podkladového typu:

<syntaxhighlight lang="cpp">
enum Enum3 : unsigned long {Val1 = 1, Val2};
</syntaxhighlight>

V tomto případě jsou výčtová jména definována s rozsahem platnosti výčtu (<code>Enum3::Val1</code>), ale pro zpětnou kompatibilitu jsou také umístěna v obklopujícím rozsahu platnosti.

V C++11 jsou také možné dopředné deklarace výčtových typů. Dříve výčtové typy nemohly být deklarovány dopředně, protože jejich velikost závisí na definici jejich členů. Pokud je velikost výčtového typu stanovena explicitně nebo implicitně, mohou být deklarovány dopředně:

<syntaxhighlight lang="cpp">
enum Enum1; // Nepovolené ani v C++03 ani v C++11; podkladový typ nelze určit.
enum Enum2 : unsigned int; // Povolené v C++11, podkladový typ je zadán explicitně.
enum class Enum3; // Povolené v C++11, podkladový typ je int.
enum class Enum4 : unsigned int; // Povolené v C++11.
enum Enum2 : unsigned short; // V C++11 nepovolené, protože Enum2 byl dříve deklarován s odlišným podkladovým typem.
</syntaxhighlight>

==== Pravá lomená závorka ====
Syntaktický analyzátor C++03 definuje <code>&gt;&gt;</code> vždy jako operátor posunu doprava nebo jako operátor načtení z proudu. S vnořenými deklaracemi šablon se však objevují sklony programátorů vynechávat mezery mezi dvojitými lomenými závorkami, což způsobí syntaktickou chybu.

C++11 vylepšuje specifikaci analyzátoru, takže tam, kde to má význam, bude několik pravých lomených závorek interpretováno jako uzavření seznamu argumentů šablony. Toto chování lze předefinovat pomocí závorek okolo výrazů v parametrech s použitím binárních operátorů <code>&gt;</code>, <code>&gt;=</code> nebo <code>&gt;&gt;</code>:

<syntaxhighlight lang="cpp">
template<boolTest> třída SomeType;
std::vector<sometype<1>2>> x1; // Interpretováno jako std::vector položek typu SomeType<true>,
    // za čímž je „2 >> x1“, což není syntakticky správný deklarátor. 1 je pravdivé.
std::vector<sometype<(1>2)>> x1; // Interpretováno jako std::vector pro SomeType<false>,
    // následovaný deklarátorem „x1“, což je v C++11 syntakticky správně. (1>2) je nepravdivé.
</syntaxhighlight>

==== Explicitní operátory konverze ====
Od C++98 lze používat klíčové slovo <code>explicit</code> jako modifikátor konstruktorů, aby se zabránilo použití konstruktorů s jedním argumentem jako implicitním operátorům konverze typu. Pro skutečné konverzní operátory to však nic neznamená. Například třída smart pointery může mít <code>operator bool()</code>, který umožní, aby se chovala více jako primitivní ukazatele: pokud obsahuje tuto konverzi, lze ji testovat pomocí s <code>if (smart_ptr_variable)</code> (což je pravdivé,, pokud ukazatel je nenulový a nepravdivé jinak). To však umožňuje i jiné, nežádoucí konverze. Protože v C++ je typ <code>bool</code> definován jako aritmetický typ, lze je implicitně konvertovat na celočíselné typy nebo dokonce typy s pohyblivou řádovou čárkou, což umožňuje matematické operace, které uživatel nezamýšlel.

V C++11 lze klíčové slovo <code>explicit</code> použít i na konverzní operátory. Stejně jako v případě konstruktorů zabrání použití těchto konverzních funkcí při implicitních konverzích. Nicméně jazykové kontexty, které specificky potřebují logickou hodnotu (podmínky if-příkazů a smyček, a operandy logických operátorů), se počítají jako explicitní konverze, a mohou tedy použít konverzní operátor <code>bool</code>.

Čisté řešení problému bezpečného bool je popsáno na anglických [[Wikibooks:More C++ Idioms/Safe bool|Wikibooks]].

==== Šablonové aliasy ====

Typ definovaný pomocí <code>typedef</code> může být pouze přezdívkou (synonymem) pro jiný typ, včetně synonym pro specializaci šablon se zadanými všemi skutečnými argumenty šablony. Nové šablony pomocí <code>typedef</code> vytvářet nelze:

<syntaxhighlight lang="cpp">
template <typename First, typename Second, int Third>
class SomeType;

template <typename Second>
typedef SomeType<othertype, Second, 5> TypedefName; // Chyba!
</syntaxhighlight>

Tuto konstrukci nelze přeložit. V C++11 je však možné použít šablonový alias:

<syntaxhighlight lang="cpp">
template <typename First, typename Second, int Third>
class SomeType;

template <typename Second>
using TypedefName = SomeType<othertype, Second, 5>;
</syntaxhighlight>

Klíčové slovo <code>using</code> lze v C++11 také použít pro typový aliasing:
<syntaxhighlight lang="cpp">
typedef void (*FunctionType)(double);  // Starý styl
using FunctionType = void (*)(double); // Nově zavedená syntaxe
</syntaxhighlight>

==== Neomezené uniony ====
V C++03 existují omezení, jaké typy objektů mohou být členy unionů; union například nemůže obsahovat žádný objekt, který definuje netriviální konstruktor nebo destruktor. C++11 některá z těchto omezení odstraňuje.{{Ref|n2544}}

Pokud má člen unionu netriviální [[Speciální členská funkcí|speciální členskou funkci]], překladač nebude generovat ekvivalentní členskou funkci pro union, ale taková funkce musí být definována ručně.

Jednoduchý příklad použití unionu v C++11:
<syntaxhighlight lang="cpp">
#include <new> // Pro operátor 'new'.

struct Bod
{
    Bod() {}
    Bod(int x, int y): x_(x), y_(y) {}
    int x_, y_;
};

union U
{
    int z;
    double w;
    Bod b; // Chyba C++03; povoleno v C++11.
    U() {} // Kvůli členu Bod je nutné konstruktor explicitně definovat.
    U(const Bod& pt) : b(pt) {} // Vytvoří objekt Bod pomocí seznamu inicializátorů.
    U& operator=(const Bod& pt) { new(&p) Bod(pt); return *this; } // Přiřadí objekt Bod použitím 'new'.
};
</syntaxhighlight>

Změny neovlivní existující kód, protože pouze uvolňují původní pravidla.

=== Vylepšení funkčnosti jádra jazyka ===
Tyto vlastnosti umožňují dělat věci, které byly dříve nemožné, jejich zápis byl příliš složitý nebo vyžadovaly nepřenositelné knihovny.

==== Variadické šablony ====
{{Podrobně|Variadická šablona}}

V C++11 mohou mít šablony proměnný počet parametrů, což mj. umožňuje definovat typově bezpečné [[Variadická funkce|variadické funkce]].

==== Nové řetězcové literály ====
Možnosti [[Řetězcový literál|řetězcových literálů]] v C++03 byly značně omezené; kromě řetězců dostupných v jazyce C zapisovaných v uvozovkách, které vytvářejí pole typu <code>const char</code> zakončená znakem s kódem nula, poskytuje pouze řetězce vytvářející pole typu <code>const wchar_t</code> také zakončené znakem s kódem nula; tyto řetězce širokých znaků se zapisují pomocí <code>L""</code>. <code>wchar_t</code> je široký znak nedefinované velikosti a sémantiky. Žádný z těchto literálů nenabízí podporu řetězcových literálů v [[UTF-8]], [[UTF-16]] nebo jiném [[Porovnání Unicode kódování|kódování]] [[Unicode]].

C++11 podporuje tři kódování Unicode: UTF-8, UTF-16 a [[UTF-32]]. Do definice typu <code>char</code> byla doplněno, že jeho velikost je minimálně taková, aby umožňovala ukládání osmibitového kódování UTF-8, a dostatečně velká, aby obsahovala všechny znaky základní znakové sady překladače. Původní norma C++ obsahovalo pouze druhou podmínku, u první se spoléhalo na normu jazyka C, která zaručuje velikost alespoň 8 bitů. C++11 navíc přidává dva nové znakové typy: <code>char16_t</code> pro UTF-16 a <code>char32_t</code> pro UTF-32.

Řetězcové literály pro uvedená kódování se píší takto:

<syntaxhighlight lang="cpp">
u8"Toto je UTF-8 řetězec."
u"Toto je UTF-16 řetězec."
U"Toto je UTF-32 řetězec."
</syntaxhighlight>

Typ prvního řetězec je obvyklý <code>const char[]</code>. Typ druhého řetězce je <code>const char16_t[]</code> (předpona je malé 'u'). Typ třetího řetězce je <code>const char32_t[]</code> (předpona je velké 'U').

Do řetězcových literálů v Unicode lze v C++11 snadno vkládat kódové body Unicode:

<syntaxhighlight lang="cpp">
u8"Toto je znak Unicode: \u2018."
u"Toto je větší znak Unicode: \u2018."
U"Toto je znak Unicode: \U00002018."
</syntaxhighlight>

Číslo za <code>\u</code> je v šestnáctkově soustavě, a na rozdíl od celočíselných konstant neobsahuje předponu <code>0x</code>. Identifikátor <code>\u</code> reprezentuje 16bitový kódový bod Unicode; pro vložení 32bitového kódového bodu slouží <code>\U</code> následované 32bitovým šestnáctkovým číslem. Těmito zápisy lze zadávat pouze platné kódové body Unicode; jsou zakázané např. kódové body z rozsahu U+D800–U+DFFF, které jsou rezervované pro náhradní páry v kódování UTF-16.


C++11 zavádí tzv. syrové řetězcové literály, ve kterých se před znaky uvozovky <code>"</code> a obrácené lomítko <code>\</code> nepíší obrácena lomítka, čímž lze zpřehlednit zápis literálů pro soubory [[Extensible Markup Language|XML]], skriptovací jazyky nebo regulární výrazy. Existují 2 formy zápisu, v obou literál začíná znakem R:

<pre>R"(Řetězcová obsahující \ a " )"
R"sep(Řetězcová obsahující \ a " )sep"
</pre>

V prvním případě patří do řetězce vše mezi <code>"(</code> a <code>)"</code>. Znaky <code>"</code> a <code>\</code> nejsou escapovány. Ve druhém případě začíná řetězec <code>"sep(</code>, a končí <code>)sep"</code>. <code>sep</code> je posloupnost nejvýše 16 znaků, kterými nesmí být mezery, řídicí znaky, a znaky <code>(</code>, <code>)</code> nebo <code>\</code>. Zápis <code>R"oddel("(a-z)")oddel"</code> je ekvivalentní s <code>"\"(a-z)\""</code>.

Syrové řetězcové literály lze používat i pro řetězce Unicode nebo širokých znaků:

<pre>u8R"XXX(Toto je "syrový UTF-8" řetězec.)XXX"
uR"*(Toto je "syrový UTF-16" řetězec.)*"
UR"(Toto je "syrový UTF-32" řetězec.)"
</pre>

==== Uživatelem definované literály ====
C++03 poskytuje různé literály. Zápis <code>12.5</code> je literál, který je vyhodnocen překladačem jako typ <code>double</code> s hodnotou 12,5. Přidáním sufixu <code>f</code> v <code>12.5f</code> dává hodnotu 12,5 typu <code>float</code>. Sufixové modifikátory literálů jsou opraveny podle C++ specifikace, a kód v C++03 nemůže vytvářet nové modifikátory literálů.

C++11 naproti tomu umožňuje uživateli definovat nové druhy modifikátorů literálů, které budou vytvářet objekty vycházející z řetězce znaků, které literál mění.

Transformace literálů je předefinována ve dvou různých fázích: syrové a vařené. Syrový literál je posloupnost znaků určitého typu, zatímco vařený literál má zvláštní typ. Literál <code>1234</code> v C++ je, protože jde o syrový literál, posloupností znaků <code>'1'</code>, <code>'2'</code>, <code>'3'</code>, <code>'4'</code>. Jako vařený literál, je to celé číslo 1234. C++ literál <code>0xA</code> je v syrovém tvaru <code>'0'</code>, <code>'x'</code>, <code>'A'</code>, zatímco ve vařeném tvaru je to celé číslo 10.

Literály mohou být rozšířeny v syrové i vařené formě, s výjimkou řetězcových literálů, které lze zpracovávat pouze ve vařené formě. Toto výjimka je způsobena faktem, že řetězce mají předpony, které ovlivňují určitý význam a typ příslušných znaků.

Všechny uživatelem definované literály se rozlišují příponami; definování předpon literálů není možné. Všechny přípony začínající libovolným znakem kromě podtržítka (<code>_</code>) jsou podle normy rezervované. Proto všechny uživatelem definované literály musí mít přípony začínající podtržítkem (<code>_</code>).<ref>Tímto vznikl konflikt s navrhovaným použitím (obvyklým v ostatních jazycích) podtržítka pro [[Desetinná značka|seskupování číslic]] v numerických literálech jako [[Celočíselný literál|celočíselných literálech]], takže [[C++14]] pro tento účel používá apostrof (jako [[Desetinná značka|horní čárku]]) pro seskupování.{{Citace elektronické monografie
| autor = Daveed Vandevoorde
| titul = N3448: Painless Digit Separation
| url = http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3448.pdf
| datum přístupu = 2015-08-13
| url archivu = https://web.archive.org/web/20150811140211/http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3448.pdf
| datum archivace = 2015-08-11
| nedostupné = live
| datum = 2012-09-21
| ref = harv
}}, {{Citace elektronické monografie
| autor = Lawrence Crowl
| titul = N3499: Digit Separators
| url = http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3499.html
| datum přístupu = 2015-08-13
| url archivu = https://web.archive.org/web/20150811114700/http://open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3499.html
| datum archivace = 2015-08-11
| nedostupné = live
| datum = 2012-12-19
| ref = harv
}}</ref>

Jak mají být uživatelem definované literály zpracovány, se definuje operátorem literálu, zapisovaným <code>operator ""</code>. Příklad:

<syntaxhighlight lang="cpp">
OutputType operator "" _mysuffix(const char * literal_string)
{
    // předpokládá, že OutputType má konstruktor, který bere parametr const char *
    OutputType ret(literal_string);
    return ret;
}

OutputType some_variable = 1234_mysuffix;
// předpokládá, že OutputType má metodu get_value(), která vrací double
assert(some_variable.get_value() == 1234.0)
</syntaxhighlight>

Přiřazovací příkaz <code>OutputType some_variable = 1234_mysuffix;</code> provede kód definovaný uživatelem definovanou literálovou funkcí. Této funkci se předává parametr <code>"1234"</code> ve formě řetězce ve stylu jazyka C, tj. zakončeného znakem s kódem nula.

Druhý možný mechanismus pro zpracování celočíselných syrových literálů a syrových literálů s pohyblivou řádovou čárkou používá [[Variadická šablona|variadické šablony]]:

<syntaxhighlight lang="cpp">
template<char...> OutputType operator "" _tuffix();

OutputType some_variable = 1234_tuffix;
OutputType another_variable = 2.17_tuffix;
</syntaxhighlight>

Toto instanciuje funkce na zpracování literálů, jako <code>operator "" _tuffix<'1', '2', '3', '4'>()</code>. V tomto tvaru není řetězec ukončen znakem s kódem nula. Hlavním účelem je umožnění použití klíčového slova <code>constexpr</code> v C++11 pro zajištění, že překladač bude transformovat literál v době překladu, předpokládá <code>OutputType</code> lze zkonstruovat pomocí constexpr a jde o kopírovatelný typ, a funkce na zpracování literálu je <code>constexpr</code> funkce.

Pro numerické literály je typ vařeného literálu buď <code>unsigned long long</code> pro celočíselné literály nebo <code>long double</code> pro literály s pohyblivou řádovou čárkou. (Poznámka: Nejsou třeba žádné celočíselné typy se znaménkem, protože literály se znaménkem jsou analyzovány jako výrazy, v nichž je znaménko prefixovým operátorem následovaným číslem bez znaménka.) Neexistuje žádná alternativní forma šablony:

<syntaxhighlight lang="cpp">
OutputType operator "" _suffix(unsigned long long);
OutputType operator "" _suffix(long double);

OutputType some_variable = 1234_suffix; // Používá přetížení 'unsigned long long'.
OutputType another_variable = 3.1416_suffix; // Používá přetížení 'long double'.
</syntaxhighlight>

V souladu s dříve zmíněnými novými předponami řetězců pro řetězcové literály lze použít:

<syntaxhighlight lang="cpp">
OutputType operator "" _ssuffix(const char * string_values, size_t num_chars);
OutputType operator "" _ssuffix(const wchar_t * string_values, size_t num_chars);
OutputType operator "" _ssuffix(const char16_t * string_values, size_t num_chars);
OutputType operator "" _ssuffix(const char32_t * string_values, size_t num_chars);

OutputType some_variable =   "1234"_ssuffix; // Používá přetížení 'const char *'.
OutputType some_variable = u8"1234"_ssuffix; // Používá přetížení 'const char *'.
OutputType some_variable =  L"1234"_ssuffix; // Používá přetížení 'const wchar_t *'.
OutputType some_variable =  u"1234"_ssuffix; // Používá přetížení 'const char16_t *'.
OutputType some_variable =  U"1234"_ssuffix; // Používá přetížení 'const char32_t *'.
</syntaxhighlight>

Neexistuje žádná alternativní forma šablony. Znakové literály jsou definovány podobně.

==== Paměťový model pro multithreading ====
{{Viz též|Memory model (computing)}}
C++11 standardizuje podporu [[Vlákno (informatika)|vláken]].

Tato podpora má dvě složky: paměťový model, který umožňuje koexistenci několika vláken v programu a knihovna podpora pro interakce mezi vlákna. (Viz sekce [[#Nástroje pro threading|Nástroje pro threading]].)

Paměťový model definuje, když několik vlákna mohou přístup stejný paměťový umístění, a udává, když aktualizuje jedním vlákno se stane viditelný na jiný vlákna.

==== Vláknové lokální úložiště ====
Ve vícevláknovém prostředí je běžné, že každé vlákno má některé jedinečné [[Proměnná (programování)|proměnné]]. To se děje pro lokální proměnné funkce, ale neděje se to pro globální a statické proměnné.

[[Vláknové lokální úložiště]] s novým trváním (vedle existujících trvání ''static'', ''dynamic'' a ''automatic'') je indikováno specifikátorem úložiště <code>thread_local</code>.

Libovolný objekt, který by měl mít statickou dobu trvání (tj. životnost po celou dobu provádění programu), může mít místo toho dobu trvání <code>thread_local</code>. Záměrem je, aby stejně jako jakákoli jiná proměnná se statickým trváním mohl být objekt lokální ve vlákně inicializován pomocí konstruktoru a zrušen pomocí destruktoru.

==== Explicitně implicitní speciální členské funkce ====
V C++03 překladač pro třídy, které je samy neposkytují, poskytuje implicitní konstruktor, kopírovací konstruktor, kopírovací operátor přiřazení (<code>operator=</code>) a destruktor. Tyto implicitní funkce může programátor nahradit definováním vlastních verzí. C++ také definuje několik globálních operátorů (např. <code>operator new</code>), které fungují pro všechny třídy, a které programátor může předefinovat.

Nad vytvářením těchto implicitních funkcí však je velmi malá kontrola. Provedení třída ze své podstaty necopyable, například může být uděláno deklarováním privátního kopírovacího konstruktoru a kopírovacího operátoru přiřazení bez jejich definování. Snaha používat tyto funkce je narušením [[Pravidlo jedné definice|pravidla jedné definice]] (ODR). Sice není vyžadována diagnostická zpráva normou<ref name="C++03 3.2/3">[[Mezinárodní organizace pro normalizaci|ISO]]/[[Mezinárodní elektrotechnická komise|IEC]] (2003). ''[[C++|ISO/IEC 14882]]:2003(E): Programming Languages – C++ §3.2 One definition rule [basic.def.odr]'' para. 3</ref> porušení těchto pravidel mohou způsobit chybu při linkování kódu.

V případě implicitního konstruktoru nebude překladač generovat implicitní konstruktor pokud je třída definována s ''libovolnými'' konstruktory. To je užitečné v mnoha případech, ale je také užitečné umožnit, aby třídy měly jak specializované konstruktory tak překladačem generovaný implicitní konstruktor.

C++11 umožňuje specifikovat, že se pro třídu vytvořit implicitní speciální členská funkce, stejně jako implicitní speciální členskou funkci smazat.<ref name="openstd_default_delete">{{Citace elektronické monografie
 | url = http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2210.html#%22default%22
 | titul = Defaulted and Deleted Functions – ISO/IEC JTC1 SC22 WG21 N2210 = 07-0070 – 2007-03-11
 | datum přístupu =  2012-12-20
 | datum archivace =  2012-08-19
 | url archivu = https://web.archive.org/web/20120819182910/http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2210.html#%22default%22
 | nedostupné = live
 | ref = harv
}}</ref> Následující třída explicitně vyžaduje, aby byl vytvořen implicitní konstruktor:

<syntaxhighlight lang="cpp">
class SomeType
{
    SomeType() = default; // Implicitní konstruktor je explicitně uveden.
    SomeType(OtherType hodnota);
};
</syntaxhighlight>

==== Explicitně smazané funkce ====
C++11 umožňuje explicitně zakázat (smazat) funkci. Toho lze použít pro zabránění implicitním typovým konverzím.
Specifikátor <code>= delete</code> lze použít pro znemožnění volání funkce s určitými typy parametrů.<ref name="openstd_default_delete" /> Například:
<syntaxhighlight lang="cpp">
void noInt(double i);
void noInt(int) = delete;
</syntaxhighlight>

Pokus zavolat funkci <code>noInt()</code> s parametrem typu <code>int</code> překladač ohlásí jako chybu, místo toho aby provedl tichou konverzi na typ <code>double</code>. Volání funkce <code>noInt()</code> s parametrem typu <code>float</code> stále funguje.

Pomocí šablony je také možné zakázat volání funkce s libovolným jiným typem parametru než <code>double</code>:
<syntaxhighlight lang="cpp">
double onlyDouble(double d) {return d;}
template<typename T> double onlyDouble(T) = delete;
</syntaxhighlight>

Volání <code>onlyDouble(1.0)</code> bude fungovat, ale pro <code>onlyDouble(1.0f)</code> překladač ohlásí chybu.

Členské funkce tříd a konstruktory mohou být také smazány. Je například možné zabránit kopírování objektů třídy smazáním kopírovacího konstruktoru a přiřazovacího operátoru <code>operator =</code>:

<syntaxhighlight lang="cpp">
class NonCopyable
{
    NonCopyable();
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
};
</syntaxhighlight>

==== Typ long long int ====
V C++03 je největším celočíselným typem <code>long int</code>. Co se týče jeho velikosti, je pouze zaručeno, že má alespoň tolik použitelných bitů jako <code>int</code>. V některých implementacích má <code>long int</code> velikost 64 bitů a v jiných 32 bitů. C++11 proto přidává nový celočíselný typ <code>long long int</code>, u něhož je zaručeno, že je alespoň stejně velký jako <code>long int</code>, a že má alespoň 64 bitů. Tento typ byl původně zaveden normou [[C99]] jazyka C, a většina překladačů C++ jej již podporovala jako rozšíření.<ref>{{Citace elektronické monografie
 | url = https://gcc.gnu.org/onlinedocs/gcc/Long-Long.html
 | titul = Using the GNU Compiler Collection (GCC): Long Long
 | vydavatel = gcc.gnu.org
 | datum přístupu = 2016-07-25
 | datum archivace = 2016-08-21
 | url archivu = https://web.archive.org/web/20160821113233/http://gcc.gnu.org/onlinedocs/gcc/Long-Long.html
 | nedostupné = live
 | ref = harv
}}</ref><ref>{{Citace elektronické monografie
 | url = http://msdn.microsoft.com/en-us/library/s3f49ktz(VS.80).aspx
 | titul = Data Type Ranges (C++)
 | datum přístupu = 2009-04-23
 | datum archivace = 2009-02-21
 | url archivu = https://web.archive.org/web/20090221114127/http://msdn.microsoft.com/en-us/library/s3f49ktz(VS.80).aspx
 | nedostupné = live
 | ref = harv
}}</ref>

==== Statické aserce ====
C++03 poskytuje dvě metody testování [[Aserce|asercí]]: makro <code>assert</code> a direktivu preprocesoru <code>#error</code>. Žádná z nich však není vhodná pro použití v šablonách: makro testuje aserci v době provádění, a direktiva preprocesoru testuje aserci při zpracování preprocesorem, což je před instanciací šablony. Žádná není vhodná pro testování vlastností, které jsou závislé na parametrech šablony.

Nový nástroj přináší nový způsob testování aserce v době překladu s použitím nového klíčového slova <code>static_assert</code>.
Deklarace předpokládá tento tvar:
 static_assert (''konstantní-výraz'', ''chybová-zpráva'');

Následující příklady ukazují použití <code>static_assert</code>:
<syntaxhighlight lang="cpp">
static_assert((GREEKPI > 3.14) && (GREEKPI < 3.15), "GREEKPI je nepřesný!");
</syntaxhighlight>
<syntaxhighlight lang="cpp">
template<classT>
struct Check
{
    static_assert(sizeof(int) <= sizeof(T), "T není dostatečně velký!");
};
</syntaxhighlight>
<syntaxhighlight lang="cpp">
template<classIntegrál>
Integral foo(Integral x, Integral y)
{
    static_assert(std::is_integral<integral>::value, "parametr foo() musí být celočíselného typu.");
}
</syntaxhighlight>

Když je konstantní výraz nepravdivý (<code>false</code>), překladač vyprodukuje chybovou zprávu. První příklad je podobný direktivě preprocesoru <code>#error</code>, i když preprocessor podporuje pouze celočíselné typy.<ref>Samuel P. Harbison III, Guy L. Steele Jr.: "C – A Reference Manual", 5th edition, p.251</ref> Naproti tomu, v druhém příkladu je aserce zkontrolována v každé instanciaci šablonové třídy <code>Check</code>.

Statické aserce jsou užitečné také mimo šablony. Například určitá implementace algoritmu může záviset na tom, že velikost <code>long long</code> je větší než <code>int</code>, což standard nezaručuje. Takový předpoklad je platný na většině systémů a překladačů, ale ne na všech.

==== Umožnění aplikace sizeof na členy třídy bez explicitního objektu ====
V C++03 je možné používat operátor <code>[[sizeof]]</code> na typy a objekty. Toto však nelze provést:

<syntaxhighlight lang="cpp">
struct SomeType { OtherType clen; };

sizeof(SomeType::clen); // Dostupné v C++11, nedostupné v C++03.
</syntaxhighlight>

Toto musí vracet velikost typu <code>OtherType</code>. V C++03 je to zakázané a způsobí to chybu při překladu. V C++11 je to dovolené. Totéž je možné pro operátor <code>alignof</code> zavedený v C++11.

==== Ovlivňování zarovnání objektu a dotaz na něj ====
C++11 umožňuje proměnná zarovnání být dotazovaný a řízený s <code>alignof</code> a <code>alignas</code>.

Operátor <code>alignof</code> bere typ a vrátí hranice mocninu 2 byte na který typ instancemi musí být přidělené (protože <code>std::size_t</code>). Když daný reference typ <code>alignof</code> vrátí zarovnání referencovaného typu; pro pole vrací zarovnání typu prvku.

Specifikátor <code>alignas</code> řídí zarovnání paměti pro proměnnou. Parametrem specifikátoru je konstanta nebo typ; je-li použit typ, je <code>alignas(T)</code> zkratkou za <code>alignas(alignof(T))</code>. Například pro zajištění, že pole typu char musí být správně zarovnané pro uložení hodnoty typu float:
<syntaxhighlight lang="cpp">
alignas(float) unsigned char c[sizeof(float)]
</syntaxhighlight>

==== Umožnění implementace garbage collectoru ====
Předchozí normy C++ umožňovaly implementaci vlastního garbage collectoru pomocí <code>set_new_handler</code>, ale pro jeho použití nedefinovaly dosažitelnost objektu. C++11 definuje podmínku, za které jsou hodnoty ukazatele „bezpečně odvozeny“ z jiné hodnoty. Implementace může specifikovat, že vyžaduje ''striktní bezpečnost ukazatelů'', aby ukazatele, které nejsou odvozeny podle těchto pravidel, se mohly stát neplatnými.

==== Atributy ====
C++11 poskytuje standardizovanou syntaxi pro rozšiřování jazyka. Taková rozšíření se tradičně zadávala pomocí direktivy <code>#pragma</code> nebo pomocí proprietárních klíčových slov (jako <code>__attribute__</code> pro GNU překladač nebo <code>__declspec</code> pro překladač od Microsoftu). S novou syntaxí je možné přidané informace specifikovat ve formě atributu zapsaného ve dvojitých hranatých závorkách. Atribut lze aplikovat na různé části zdrojového kódu:
<syntaxhighlight lang="cpp">
int [[attr1]] i [[attr2, attr3]];

[[attr4(arg1, arg2)]], if (cond)
{
    [[vendor::attr5]] return i;
}
</syntaxhighlight>
Ve výše uvedeném příkladu se atribut <code>attr1</code> uplatní na typ proměnné <code>i</code>, <code>attr2</code> a <code>attr3</code> na samotnou proměnnou, <code>attr4</code> platí pro příkaz <code>if</code> a <code>vendor::attr5</code> se uplatní na příkaz <code>return</code>. Obecně (s několika výjimkami) atribut specifikovaný pro pojmenovanou entitu je umístěn po jméně, a před entitou, jinak, jak je ukázáno výše, může být několik atributů uvedeno v jedné dvojici dvojitých hranatých závorek, přidané argumenty mohou být poskytnuty pro atribut, a atributy mohou mít rozsah platnosti podle jmenných prostorů proprietárních atributů.

Doporučuje se, aby atributy neměly žádný sémantický význam v jazyce, a aby se neměnil smysl programu, pokud jsou ignorovány. Atributy mohou být užitečné pro poskytnutí informace, která například pomůže překladači vydat lepší diagnostiku nebo optimalizovat generovaný kód.

C++11 poskytuje dva standardní atributy: <code>noreturn</code>, který udává, že funkce nemá návratovou hodnotu, a <code>carries_dependency</code>, který pomáhá optimalizovat multithreadový kód uvedením, že argumenty funkce nebo její návratová hodnota přenášejí závislost.{{clarify|datum=September 2014}}

== Změny standardní knihovny C++ ==
Ve standardní knihovně C++11 bylo zavedeno několik nových vlastností. Mnoho jich mohlo být implementováno i podle starší normy, ale některé spoléhají (ve větší či menší míře) na nové základní vlastnosti C++11.

Velká část nové [[Knihovna (programování)|knihovny]] byla definována v dokumentu ''[[Technická zpráva 1|C++ Standards Committee's Library Technical Report]]'' (nazývaný TR1), který byl publikován v roce 2005. Různé plné a částečné implementace TR1 jsou aktuálně dostupné použitím jmenného prostoru <code>std::tr1</code>. Pro C++11 byly přesunuty do jmenného prostoru <code>std</code>. Protože však TR1 vlastnosti byly přeneseny do standardní knihovny C++11, byly nahrazeny příslušnými jazykovými vlastnostmi C++11, které v počáteční TR1 verzi nebyly dostupné. Také mohly být nahrazeny vlastnostmi, které byly dostupné v C++03, ale nebyly částí původní specifikace v TR1.

=== Rozšíření standardní knihovny ===
Nové hlavičkové soubory:
* chrono: práce s časem
* codevct: konverze [[Unicode]] kódování
* random: pokročilé [[Generátor pseudonáhodných čísel|generování pseudonáhodných čísel]]
* ratio: zlomky, vyhodnocené v době kompilace
* regex: podpora regulárních výrazů

=== Vylepšení komponent standardní knihovny ===
C++11 poskytuje několik nových vlastností, které mohou s výhodou využívat již existující komponenty standardní knihovny. Většina kontejnerů standardní knihovny může například využívat podporu přesunových konstruktorů používajících Rvalue reference, jak pro rychlé přesuny těžkých kontejnerů tak pro přesun obsahu těchto kontejnerů na jiné paměťové lokace. Tam, kde to bylo možné, byly komponenty standardní knihovny vylepšeny o nové jazykové vlastnosti definované v C++11, mimo jiné pro:

* rvalue reference a s nimi související podporu přesunu
* podporu kódovacích jednotek UTF-16 a kódovacích jednotek UTF-32 pro znakové typy Unicode
* [[Variadická šablona|variadické šablony]] (spolu s Rvalue referencemi pro umožnění dokonalého forwardingu)
* výrazy konstantní v době překladu
* <code>[[decltype]]</code>
* <code>explicit</code> konverzní operátory
* funkce deklarované defaulted nebo smazaný

Od předešlé normy C++ uplynulo hodně času, během něhož bylo vytvořeno množství kódu, který používá standardní knihovnu, při čemž byly odhaleny složky standardní knihovny, které bylo možné vylepšit. Příkladem je komponenta [[allocator (C++)|allocator]]. Do jazyka C++11 byl začleněn nový model alokátorů založený na [[Rozsah platnosti|oblastech platnosti]], který doplňuje předchozí model.

=== Nástroje pro threading ===
C++03 poskytuje paměťový model, který podporuje threading, ale primární podpora pro skutečné použití threadingu přišla až se standardní knihovnou C++11.

Knihovna definuje třídu (<code>std::thread</code>) s podporou vláken, která používá [[objekt funkce]] (s volitelnou řadou argumentů, které ji lze předat) pro jeho spuštění v novém vlákně. Vlákno je možné pozastavit, dokud neskončí jiné běžící vlákno s využitím členské funkce <code>std::thread::join()</code> pro spojování vláken. Tam, kde je to možné, je poskytnut přístup k podkladovému nativnímu objektu nebo objektům vlákna pro operace podporované použitou [[Počítačová platforma|výpočetní platformou]] pomocí členské funkce <code>std::thread::native_handle()</code>.

Pro synchronizaci vláken byly do knihovny přidány příslušné [[Vzájemné vyloučení|mutexy]] (<code>std::mutex</code>, <code>std::recursive_mutex</code>, atd.) a [[Monitor (synchronizace)|podmínkové proměnné]] (<code>std::condition_variable</code> a <code>std::condition_variable_any</code>), které jsou dostupné prostřednictvím zámků RAII (Resource Acquisition Is Initialization) (<code>std::lock_guard</code> a <code>std::unique_lock</code>) a zamykacích algoritmů pro snadné použití.

Pro vysokou výkonnost při nízkoúrovňové práci je někdy potřebná komunikace mezi vlákna bez režie mutexů. K tomu se používají [[Atomická operace|atomické operace]] nad paměťovými místy. Ty mohou volitelně specifikovat minimální omezení viditelnosti paměti potřebná pro danou operaci. K tomuto účelu lze také použít explicitní [[Paměťová bariéra|paměťové bariéry]].

Vláknová knihovna C++11 obsahuje také [[futures a promises]] pro předávání asynchronních výsledků mezi vlákny a <code>std::packaged_task</code> pro zabalení volání funkcí, která mohou generovat takový asynchronní výsledek. Návrh futures byl kritizován, protože postrádá způsob, jak kombinovat futures a kontrolovat dokončení jednoho slibu uvnitř sady slibů.<ref>{{Citace elektronické monografie
 | příjmení = Milewski
 | jméno = Bartosz
 | titul = Broken promises–C++0x futures
 | datum = 2009-03-03
 | url = http://bartoszmilewski.wordpress.com/2009/03/03/broken-promises-c0x-futures/
 | datum přístupu = 2010-01-24
 | datum archivace = 2011-09-16
 | url archivu = https://web.archive.org/web/20110916155404/http://bartoszmilewski.wordpress.com/2009/03/03/broken-promises-c0x-futures/
 | nedostupné = live
 | ref = harv
}}</ref>

Další vysokoúrovňové nástroje pro práci s vlákny, např. [[Fond vláken|fondy vláken]] byly odloženy do budoucí [[Technická zpráva 1|technické zprávy]] o C++. Nejsou součástí C++11, ale očekává se, že jejich výsledná implementace bude postavena zcela nad vlastnostmi vláknové knihovny.

Nový prostředek <code>std::async</code> poskytuje pohodlnou metoda spouštění úloh a jejich navázání na <code>std::future</code>. Uživatel si může vybrat, zda má být úloha spuštěna asynchronně na samostatném vlákně nebo synchronně na vlákně, které čeká na hodnotu. Implicitně si implementace může vybrat, což poskytuje snadný způsob, jak využít výhodu hardwarové souběžnosti bez oversubscription, a poskytuje některé výhody fondu vláken pro jednoduchá použití.

=== N-tice ===
[[Uspořádaná n-tice]] ({{Vjazyce2|en|''tuple''}}) je kolekce předem daných rozměrů složená z heterogenních objektů. N-tice lze považovat za zobecnění členských proměnných struktur.

C++11 verze TR1 typu n-tic využívají C++11 vlastností jako [[#Variadické šablony|variadické šablony]]. Pro rozumnou implementaci TR1 verze vyžadovaly implementací definovaný maximální počet obsažených typů, a značné použití triků s makry. Oproti tomu, implementace verze C++11 nevyžaduje žádný explicitní implementací definovaný maximální počet typů. I když překladače budou mít interní maximální hloubku rekurze pro instanciaci šablon (což je normální), n-tice podle C++11 nebudou tuto hodnotu ukazovat uživateli.

S použitím [[Variadická šablona|variadických šablon]] vypadá deklarace třídy n-tic takto:
<syntaxhighlight lang="cpp">
template <class...Types> class tuple;
</syntaxhighlight>

Příklad definice a použití typu n-tice:
<syntaxhighlight lang="cpp">
typedef std::tuple <int, double, long &, const char *> test_tuple;
long lengthy = 12;
test_tuple proof (18, 6.5, lengthy, „Ciao!“);

lengthy = std::get<0>(proof);    // Přiřadí do 'lengthy' hodnotu 18.
std::get<3>(proof) = „ Krásný!“; // Změní čtvrtý prvek n-tice.
</syntaxhighlight>

Je možné vytvořit n-tici <code>proof</code> bez definování jejího obsahu, ale pouze pokud typy prvků n-tice mají implicitní konstruktory. Navíc je možné přiřadit n-tici do jiné n-tice; pokud dva typy n-tic jsou stejné, každý typ prvku musí mít kopírovací konstruktor; jinak, každý typ prvku n-tice na pravé straně operátoru přiřazení musí být zkonvertovatelný na typ odpovídajícího prvku na levé straně n-tice nebo odpovídající typ prvku v n-tici na levé straně musí mít vhodný konstruktor.
<syntaxhighlight lang="cpp">
typedef std::tuple <int , double, string       > tuple_1 t1;
typedef std::tuple <char, short , const char * > tuple_2 t2 ('X', 2, „Hola!“);
t1 = t2; // Ok, první dva prvky mohou být zkonvertovány,
         // třetí prvek lze vytvořit z 'const char *'.
</syntaxhighlight>

Stejně jako <code>std::make_pair</code> pro <code>std::pair</code> existuje <code>std::make_tuple</code> pro automatické vytváření <code>std::tuple</code> s použití vyvozování typů; pro deklarování takových n-tic lze použít <code>auto</code>. <code>std::tie</code> vytváří n-tice lvalue reference pro usnadnění rozbalování n-tic. Přitom také může pomoci <code>std::ignore</code>. Příklad:

<syntaxhighlight lang="cpp">
auto zaznam = std::make_tuple(“Hari Ram“, „New Delhi“, 3.5, 'A');
std::string name ; float gpa ; char grade ;
std::tie(jmeno, std::ignore, gpa, grade) = zaznam ; // std::ignore umožňuje vypustit jméno města
std::cout << jmeno << ' ' << gpa << ' ' << grade << std::endl ;
</syntaxhighlight>

Jsou dostupné relační operátory (mezi n-ticemi se stejným počtem prvků), a jsou dostupné dva výrazy pro zjištění charakteristik n-tice (pouze během překladu):
* <code>std::tuple_size<nowiki><t></nowiki>::value</code> vrátí počet prvků v n-tice <code>T</code>,
* <code>std::tuple_element<nowiki><i, T></nowiki>:: typ</code> vrátí typ objektu s číslem <code>I</code> v n-tici <code>T</code>.

=== Hašovací tabulky ===
Zahrnutí [[Hašovací tabulka|hašovacích tabulek]] (neuspořádaných asociativních kontejnerů) do standardní knihovny C++ bylo jedním z nejčastěji se opakujících požadavků, který nebyl obsažen v C++03 pouze z časových důvodů. I když jsou v nejhorším případě (při existenci mnoha kolizí) hašovací tabulky méně efektivní než [[Vyvážený strom|vyvážené stromy]], v mnoha reálných aplikacích fungují lépe.

Kolize jsou řešené pouze pomocí ''[[Hašovací tabulka|lineárního řetězení]]'', protože komise nepovažovala za vhodné standardizovat řešení ''[[Otevřený adresování|otevřeného adresování]]'', které přináší množství vnitřních problémů (především když je povoleno mazání položek). Aby se zabránilo kolizím jmen s nestandardními knihovnami, které vyvinuly vlastní implementace hašovacích tabulek, byla místo “hash” použita předpona “unordered”.

Nová knihovna má čtyři typy hašovacích tabulek, které se liší podle toho, zda dovolují prvky se stejným klíčem (jedinečné klíče nebo ekvivalentní klíče), a zda mapují každý klíč na přidruženou hodnotu. Odpovídají čtyřem existujícím asociativním kontejnerům založeným na [[Binární vyhledávací strom|binárních vyhledávacích stromech]] s předponou <code>unordered_</code>.

{| class="wikitable" style="text-align: center"
! Typ hašovací tabulky !! Přidružené hodnoty !! Ekvivalentní klíče
|-
| style="text-align: left" | <code>[[Neuspořádaný asociativní kontejner (C++)|std::unordered_set]]</code>      || ne  || ne
|-
| style="text-align: left" | <code>[[Neuspořádaný asociativní kontejner (C++)|std::unordered_multiset]]</code> || ne || ano
|-
| style="text-align: left" | <code>[[Neuspořádaný asociativní kontejner (C++)|std::unordered_map]]</code>      || ano || ne
|-
| style="text-align: left" | <code>[[Neuspořádaný asociativní kontejner (C++)|std::unordered_multimap]]</code> || ano || ano
|}

Nové třídy splňují všechny požadavky kladené na [[Standard Template Library|kontejnervou třídu]], a mají všechny metody potřebné pro přístup k prvkům: <code>insert</code>, <code>erase</code>, <code>begin</code>, <code>end</code>.

Hašovací tabulky nevyžadovaly žádné rozšíření jádra jazyka C++ (i když implementace budou využívat různé vlastnosti jazyka C++11), pouze malé rozšíření hlavičkového souboru <code><nowiki><functional></nowiki></code> a zavedení hlavičkových souborů <code><nowiki><unordered_set></nowiki></code> a <code><nowiki><unordered_map></nowiki></code>. Žádné další změny v existujících standardních třídách nebyly potřebné, a nové rysy nezávisejí na jiných rozšířeních standardní knihovny.

=== std::array a std::forward_list ===
Kromě hašovací tabulek byly do standardní knihovny přidány dva další kontejnery. <code>std::array</code> je kontejner pevné velikosti, který je efektivnější než <code>std::vector</code>, ale bezpečnější a snáze použitelný než pole ve stylu jazyka C. <code>std::forward_list</code> je jednoduchý spojový seznam, který poskytuje prostorově efektivnější ukládání než obousměrný spojový seznam <code>std::list</code>, když není potřeba obousměrné procházení.

==={{Kotva|regex}} Regulární výrazy ===

Nová knihovna definovaná v novém hlavičkovém souboru <code><nowiki><regex></nowiki></code>, je tvořena několika novými třídami:
* [[regulární výraz]]y jsou reprezentovány instancí šablonové třídy <code>std::regex</code>;
* výskyty jsou reprezentovány instancí šablonové třídy <code>std::match_results</code>,
* pro iteraci přes všechny možnosti, jak napasovat regulární výraz na řetězec, se používá <code>std::regex_iterator</code>

Funkce <code>std::regex_search</code> se používá pro samotné vyhledávání, zatímco pro ‘vyhledání a nahrazení’ se používá funkce <code>std::regex_replace</code>, která vrací upravený řetězec.<ref>{{Citace elektronické monografie
 | titul = C++ Regular expressions library
 | url = https://en.cppreference.com/w/cpp/regex
 | vydavatel = cppreference.com
 | datum přístupu = 2022-12-10
 | ref = harv
}}</ref>

Příklad použití <code>std::regex_iterator</code>:
<syntaxhighlight lang="cpp">
#include <regex>
const char *vzorek = R“([^ ,.\t\n]+)“; // najde slova oddělená mezerou, čárkou, tečkou, tabelátorem, znakem konce řádku

std::regex rgx(vzorek); // pro neplatný vzorek vyhodí výjimku

const char *target = „Unseen University - Ankh-Morpork“;

// Použij regex_iterator pro identifikaci všech slov s 'target' odděleným znaky 'vzorku'.
auto iter =
    std::cregex_iterator(target, target + strlen(target), rgx);

// ukončí iterátor posloupnosti
auto end =
    std::cregex_iterator();

for (; iter != end; ++iter)
{
  std::string match_str = iter->str();
  std::cout << match_str << '\n';
}
</syntaxhighlight>

Knihovna <code><nowiki><regex></nowiki></code> nevyžaduje žádné úpravy libovolné existující hlavičkových souborů (i když bude používat jim kde je to vhodné) ani rozšíření jádra jazyka. V [[POSIX]] iverzi jazyka C jsou regulární výrazy také dostupné pomocí [[C POSIX knihovna#regex.h]].

=== Univerzální smart pointery ===
{{Podrobně|Smart_pointer#C++ smart pointers|l1=C++ smart pointers}}
C++11 poskytuje {{code|std::unique_ptr}}, a vylepšení na {{code|std::shared_ptr}} a {{code|std::weak_ptr}} z TR1. {{code|std::auto_ptr}} je nedoporučovaný.

=== Rozšiřitelné nástroje pro generování náhodných čísel ===
Standardní knihovna jazyka C umožňuje generovat [[pseudonáhodný číslo|pseudonáhodná čísla]] pomocí funkce <code>rand</code>. Algoritmus je plně delegován na knihovnu dodavatele. C++ zdědil toto funkčnost beze změn, ale C++11 poskytuje novou metodu pro generování pseudonáhodných čísel.

Vytváření náhodných čísel v C++11 je rozděleno na dvě části: generátor, který obsahuje generátor stavu náhodných čísel a produkuje pseudonáhodná čísla; a rozdělení, které určuje rozsah a [[Distribuce (matematika)|matematické rozdělení]] výsledku. Tyto dvě části jsou zkombinovány pro vytvoření objektu generátoru náhodných čísel.

Kromě standardní funkce <code>rand</code> z jazyka C, C++11 mechanismus přichází se třemi základními strojovými algoritmy generátoru:
* [[Lineární kongruentní generátor]]: <code>linear_congruential_engine</code>,
* [[Odečtení s přenosem]]: <code>subtract_with_carry_engine</code>, a
* [[Mersenne twister]]: <code>mersenne_twister_engine</code>.

C++11 také poskytuje několik nejpoužívanějších rozdělení:
* [[Rovnoměrné rozdělení (diskrétní)]]: <code>uniform_int_distribution</code>,
* [[Rovnoměrné rozdělení]]: <code>uniform_real_distribution</code>,
* [[Alternativní rozdělení]]: <code>bernoulli_distribution</code>,
* [[Binomické rozdělení]]: <code>binomial_distribution</code>,
* [[Geometrické rozdělení]]: <code>geometric_distribution</code>,
* [[Negativně binomické rozdělení]]: <code>negative_binomial_distribution</code>,
* [[Poissonovo rozdělení]]: <code>poisson_distribution</code>,
* [[Exponenciální rozdělení]]: <code>exponential_distribution</code>,
* [[Rozdělení gama]]: <code>gamma_distribution</code>,
* [[Weibullovo rozdělení]]: <code>weibull_distribution</code>,
* [[Zobecněný extrémní hodnota rozdělení]]: <code>extreme_value_distribution</code>,
* [[Normální rozdělení]]: <code>normal_distribution</code>,
* [[Logaritmicko-normální rozdělení]]: <code>lognormal_distribution</code>,
* [[Rozdělení chí kvadrát]]: <code>chi_squared_distribution</code>,
* [[Cauchyho rozdělení]]: <code>cauchy_distribution</code>,
* [[Rozdělení F]]: <code>fisher_f_distribution</code>,
* [[Studentovo rozdělení]]: <code>student_t_distribution</code>,
* [[Rozdělení pravděpodobnosti]]: <code>discrete_distribution</code>,
* [[Schodovitá funkce]]: <code>piecewise_constant_distribution</code> a
* [[Po částech lineární funkce]]: <code>piecewise_linear_distribution</code>.

Generátor a distribuci lze kombinovat jako v tomto příkladě:

<syntaxhighlight lang="cpp">
#include <random>
#include <functional>

std::uniform_int_distribution<int> rozdeleni(0, 99);
std::mt19937 stroj; // Mersenneho twister MT19937
auto generator = std::bind(rozdeleni, stroj);
int random = generator(); // Generuje rovnoměrně rozdělená celá čísla mezi 0 a 99.
int random2 = distribution(stroj); // Generují jiný vzorek přímo pomocí objektů rozdělení a stroj.
</syntaxhighlight>

=== Adaptér ===
[[Adaptér (návrhový vzor)|Adaptér]] ({{Vjazyce2|en|''wrapper''}}) se získá z instance šablony třídy <code>reference_wrapper</code>. Adaptéry jsou podobné normálním referencím (<code>&amp;</code>) v jazyce C++. Pro získání adaptéru z libovolného objektu se používá funkční šablona <code>ref</code> (pro konstantní reference <code>cref</code>).

Adaptéry jsou užitečné především pro funkční šablony, kde jsou potřeba reference na parametry, nikoli kopie:
<syntaxhighlight lang="cpp">
// Tato funkce dostane odkaz na parametr 'r' a inkrementuje jej.
void func (int &r) { r++; }

// Funkční šablona.
template<class F, class P> void g (F f, P t) { f(t); }

int main()
{
    int i = 0;
    g (func, i); // 'g<void(int &r), int>' je instanciováno
                 // pak 'i' nebude změněno.
    std::cout << i << std::endl; // Vypíše -> 0

    g (func, std::ref(i)); // 'g<void(int &r),reference_wrapper<int>>' je instanciováno
                           // pak 'i' bude změněno.
    std::cout << i << std::endl; // Vypíše -> 1
}
</syntaxhighlight>

Tento nový nástroj byl přidán k existujícímu hlavičkovému souboru <code><nowiki><functional></nowiki></code> a nevyžaduje další rozšíření jazyka C++.

=== Polymorfní adaptéry pro objekty funkcí ===
[[Polymorfismus (programování)|Polymorfní]] [[Adaptér (návrhový vzor)|adaptéry]] pro [[funkční objekt|objekty funkcí]] se sémanticky a syntakticky podobají [[Ukazatel na funkci|ukazatelům na funkce]], ale jsou méně striktně vázaný a mohou se bez rozdílů odkazovat na cokoli, co lze volat (ukazatele na funkce, ukazatele na členské funkce nebo funktory), jejichž argumenty jsou kompatibilní s argumenty adaptéru.

Příklad může vyjasnit jeho charakteristiky:
<syntaxhighlight lang="cpp">
std::function<int(int, int)> func; // Vytvoření adaptéru použitím
                                 // šablonové třídy 'function'.
std::plus<int> add; // 'plus' je deklarováno jako 'šablona<classT> T plus( T, T ) ;'
                    // pak 'add' je typu 'int add( int x, int y )'.
func = add; // OK - Parametry a návratové typy jsou stejné.

int = func (1, 2); // POZNÁMKA: pokud se adaptér 'func' neodkazuje na žádnou funkce,
                   // bude vyhozena výjimka 'std::bad_function_call'.

std::function<bool(short, short)> func2 ;
if (!func2)
{
    // Pravdivé, protože do 'func2' ještě nebyla přiřazena funkce.

    bool adjacent(long x, long y);
    func2 = &adjacent; // OK - Parametry a návratové typy jsou konvertovatelné.

    struct Test
    {
        bool operator()(short x, short y);
    };
    Test vozidlo;
    func = std::ref(vozidlo); // 'std::ref' je šablona funkce, které vrací adaptér
                              // členské funkce 'operator()' struktury 'vozidlo'.
}
func = func2; // OK - Parametry a návratové typy jsou konvertovatelné.
</syntaxhighlight>

Šablonová třída <code>function</code> je definována v hlavičkovém souboru <code><nowiki><functional></nowiki></code> bez potřeby měnit jazyk C++.

=== Typ rysy pro metaprogramování ===
[[Metaprogramování]] je vytváření programů, které vytvářejí nebo mění jiný program (nebo sebe sama). K tomu může docházet při překladu nebo při provádění. [[ISO/IEC JTC 1/SC 22|Standardizační komise C++]] se rozhodla zavést knihovnu pro metaprogramování během překladu se šablonami.

Následující metaprogram používá [[Rekurze|rekurzi]] instancí šablon pro výpočet celočíselných mocnin podle normy C++03:

<syntaxhighlight lang="cpp">
template<intB, int N>
struct Pow
{
    // rekurzivní volání a rekombinace.
    enum{ hodnota = B*Pow<b, N-1>::value };
};

template< int B >
struct Pow<b, 0>
{
    // ''N == 0'' podmínka pro ukončení.
    enum{ hodnota = 1 };
};
int tri_na_ctvrtou = Pow<3, 4>::value;
</syntaxhighlight>

Mnoho algoritmů může pracovat s různými typy dat; [[Šablona (programování)|šablony]] v C++ podporují [[generické programování]] a činí kód kompaktnější a užitečnější. Často však algoritmy potřebují informace o typech dat, které používají. Tyto informace lze získat při instanciaci šablony třídy pomocí ''typových rysů''.

''Typové rysy'' mohou identifikovat kategorii objektu a všechny charakteristiky třídy (nebo struktury). Jsou definovány v novém hlavičkovém souboru <code><nowiki><type_traits></nowiki></code>.

V dalším příkladě existuje šablonová funkce ‘elaborate’, který v závislosti na daný datové typy, bude instanciovat jeden ze dvou navržený algoritmy (<code>Algoritmus::do_it</code>).

<syntaxhighlight lang="cpp">
// Poprvé způsob of fungující.
template< bool B > struct Algoritmus
{
    template<classT1, class T2> static int do_it (T1 &, T2 &) { /*...*/ }
};

// Druhý způsob of fungující.
template<> struct Algoritmus<true>
{
    template<classT1, class T2> static int do_it (T1, T2) { /*...*/ }
};

// Instanciace 'elaborate' bude automaticky instanciovat správný způsob jak pracovat.
template<classT1, class T2>
int elaborate (T1 A, T2 B)
{
    // Druhý způsob použít, pouze pokud 'T1' je celé číslo a 'T2' číslo
    // s pohyblivou řádovou čárkou, jinak použít první způsob.
    return Algorithm<std::is_integral<t1>::value && std::is_floating_point<t2>::value>::do_it( A, B ) ;
}
</syntaxhighlight>

Pomocí ''typových rysů'' definovaných v hlavičkovém souboru <code><nowiki><type_traits></nowiki></code> je také možné vytvářet operace pro transformace typů (<code>static_cast</code> a <code>const_cast</code> jsou uvnitř šablony nedostatečné).

Tento typ programování vytváří elegantní a stručný kód; slabinou těchto techniky však je ladění: je nepříjemné při překladu a velmi obtížné při provádění programu.

=== Uniformní metoda výpočtu návratového typu funkčních objektů ===
Určování návratového typu objektu šablony funkce v době překladu není intuitivní. Zejména pokud návratová hodnota závisí na parametrech funkce. Jako příklad:

<syntaxhighlight lang="cpp">
struct Clear
{
    int operator()(int) const;       // Typ parametru je
    double operator()(double) const; // stejný jako návratový typ.
};

template <classObj>
class Calculus
{
public:
    template<class Arg> Arg operator()(Arg& a) const
    {
        return member(a);
    }
private:
    Obj member;
};
</syntaxhighlight>

Instanciací šablony třídy <code>Calculus<nowiki><clear></nowiki></code>, funkce objekt of <code>calculus</code> bude mít vždy stejný návratový typ jako funkční objekt struktury <code>Clear</code>. Je-li však dána třída <code>Confused</code> níže:

<syntaxhighlight lang="cpp">
struct Confused
{
    double operator()(int) const; // Typ parametru není
    int operator()(double) const; // roven návratovému typu.
};
</syntaxhighlight>
Snaha instanciovat <code>Calculus<nowiki><confused></nowiki></code> způsobí, že návratový typ struktury <code>Calculus</code> nebude stejný jako typ třídy <code>Confused</code>. Překladač může generovat varování o konverzi z <code>int</code> na <code>double</code> a naopak.

TR1 představilo a C++11 přejalo, šablonovou třídu <code>std::result_of</code>, která umožňuje určit a používat návratový typ objektu funkce v deklaracích. Objekt <code>CalculusVer2</code> používá objekt <code>std::result_of</code> pro zjištění návratového typu objektu funkce:
<syntaxhighlight lang="cpp">
template< class Obj >
class CalculusVer2
{
public:
    template<class Arg>
    typename std::result_of<obj(Arg)>::type operator()(Arg& a) const
    {
        return member(a);
    }
private:
    Obj member;
};
</syntaxhighlight>
Díky tomu v instancích funkčního objektu <code>CalculusVer2<nowiki><confused></nowiki></code> nejsou žádné konverze, varování ani chyby.

Jedinou změnou oproti verzi <code>std::result_of</code> z TR1 je, že TR1 verze umožňovala, aby implementace selhala při určování typu výsledku volání funkce. Kvůli změnám v C++ pro podporu <code>[[#Typová inference|decltype]]</code>, <code>std::result_of</code> v C++11 již tyto speciální případy nepotřebuje; implementace musí být schopny odvodit typ ve všech případech.

== Vylepšení kompatibility s jazykem C ==

Pro kompatibilitu s [[C (programovací jazyk)|jazykem C]] podle normy C99 byly přidány tyto vlastnosti:<ref>{{Citace elektronické monografie
 | url = http://clang.llvm.org/cxx_status.html
 | titul = Clang - C++98, C++11, and C++14 Status
 | vydavatel = Clang.llvm.org
 | datum = 2013-05-12
 | datum přístupu = 2013-06-10
 | datum archivace = 2019-05-28
 | url archivu = https://web.archive.org/web/20190528214038/http://clang.llvm.org/cxx_status.html
 | nedostupné = live
 | ref = harv
}}</ref>

* Preprocessor:<ref>{{Citace elektronické monografie
 | url = http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm
 | titul = Working draft changes for C99 preprocessor synchronization
 | vydavatel = www.open-std.org
 | datum přístupu = 2014-05-26
 | datum archivace = 2020-07-31
 | url archivu = https://web.archive.org/web/20200731222757/http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm
 | nedostupné = live
 | ref = harv
}}</ref>
** [[variadické makro|variadická makra]],
** zřetězení sousedících úzkých nebo širokých řetězcových literálů,
** <code>_Pragma()</code> – ekvivalent direktivy <code>#pragma</code>.
* <code>long long</code> – celočíselný typ s velikostí nejméně 64 bitů
* <code>__func__</code> – makro, které se vyhodnocuje na jméno funkce, ve které je použito.
* Hlavičkové soubory:
** <code>cstdbool</code> (<code>stdbool.h</code>),
** <code>cstdint</code> (<code>stdint.h</code>),
** <code>cinttypes</code> (<code>inttypes.h</code>).

== Vlastnosti původně plánované, ale odstraněné nebo nezahrnuté ==
Hlavičky pro zvláštní TR:
* [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3347.pdf Moduly]
* Desítkové typy
* Speciální matematické funkce
Odloženo:
* [[Koncepty (C++)|Koncepty]]
* Úplnější nebo vyžadované podpora garbage kolektoru
* Reflexe
* Oblasti platnosti maker

== Odstraněné a nedoporučované vlastnosti ==

Termín [[sekvenční bod]] byl odstraněn. Je nahrazen stanovením, že jedna operace je sekvencována před jinou nebo že dvě operace nejsou sekvencované.<ref>{{Citace elektronické monografie
 | url = http://blogs.msdn.com/b/vcblog/archive/2007/06/04/update-on-the-c-0x-language-standard.aspx
 | titul = Update on the C++-0x Language Standard
 | příjmení = Caves
 | jméno = Jonathan
 | datum = 2007-06-04
 | datum přístupu = 2010-05-25
 | datum archivace = 2011-09-09
 | url archivu = https://web.archive.org/web/20110909141628/http://blogs.msdn.com/b/vcblog/archive/2007/06/04/update-on-the-c-0x-language-standard.aspx
 | nedostupné = live
 | ref = harv
}}</ref>

Původní použití klíčového slova <code>[[export (C++)|export]]</code> bylo odstraněno.<ref name="sutter0310">{{Citace elektronické monografie
 | url = http://herbsutter.com/2010/03/13/trip-report-march-2010-iso-c-standards-meeting/
 | titul = Trip Report: March 2010 ISO C++ Standards Meeting
 | příjmení = Sutter
 | jméno = Herb
 | odkaz na autora = Herb Sutter
 | datum = 2010-03-03
 | datum přístupu = 2010-03-24
 | datum archivace = 2018-07-11
 | url archivu = https://web.archive.org/web/20180711064254/https://herbsutter.com/2010/03/13/trip-report-march-2010-iso-c-standards-meeting/
 | nedostupné = live
 | ref = harv
}}</ref> Slovo <code>export</code> však zůstává klíčovým slovem, je rezervované pro případné další použití.

Dynamická [[Výjimka (programování)|specifikace výjimek]] je nedoporučovaná.<ref name="sutter0310" /> Specifikace funkcí, které nevyhazují výjimky, je v době překladu dostupná pomocí klíčového slova <code>noexcept</code>, které je užitečné pro optimalizaci.

<code>[[auto ptr|std::auto_ptr]]</code> je není nedoporučované, bylo nahrazeno <code>std::unique_ptr</code>.

Základní třídy funkčních objektů (<code>std::unary_function</code>, <code>std::binary_function</code>), adaptéry na ukazatele na funkce, adaptéry na ukazatele na členy a binder třídy jsou nyní nedoporučované.

== Odkazy ==
=== Reference ===
{{Překlad|en|C++11|1232295810}}<references />

=== Související články ===
* [[C11 (C standardní revize)|C11]]

=== Externí odkazy ===
* [http://www.open-std.org/jtc1/sc22/wg21/ The C++ Standards Committee]
* [https://web.archive.org/web/20080221185141/http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=216 C++0X: The New Face of Standard C++]
* [http://herbsutter.wordpress.com/ Herb Sutter's blog coverage of C++11]
* [http://www.justsoftwaresolutions.co.uk/cplusplus/ Anthony Williams' blog coverage of C++11]
* [http://www.csclub.uwaterloo.ca/media/C++0x%20-%20An%20Overview.html A talk on C++0x given by Bjarne Stroustrup at the University of Waterloo] {{Wayback|url=http://www.csclub.uwaterloo.ca/media/C++0x%20-%20An%20Overview.html |date=20210625165037 }}
* [http://www.devx.com/SpecialReports/Article/38813/0/page/1 The State of the Language: An Interview with Bjarne Stroustrup (15 August 2008)] {{Wayback|url=http://www.devx.com/SpecialReports/Article/38813/0/page/1 |date=20120728144552 }}
* [https://web.archive.org/web/20120520004525/http://wiki.apache.org/stdcxx/C++0xCompilerSupport Wiki page to help keep track of C++ 0x core language features and their availability in compilers]
* [http://en.cppreference.com Online C++11 standard library reference]
* [http://stacked-crooked.com/ Online C++11 compiler]
* Bjarne Stroustrup's [http://www.stroustrup.com/C++11FAQ.html C++11 FAQ]
* [https://corecplusplustutorial.com More information on C++11 features:range-based for loop,why auto_ptr is deprecated,etc. ]
* {{Citace elektronické monografie
 | url = https://cs-blog.petrzemek.net/2012-12-04-co-je-noveho-v-cpp11
 | titul = Co je nového v C++11
 | jméno = Petr
 | příjmení = Zemek
 | datum = 2012-12-04
 | datum přístupu = 2024-09-14
 | ref = harv
}}

[[Kategorie:C++]]
[[Kategorie:Standardy IEC]]
[[Kategorie:Standardy ISO]]