C++14

C++14 je verze ISO/IEC 14882 normy programovacího jazyka C++. Měla být malým rozšířením C++11 obsahujícím především opravy chyb a drobná vylepšení. Její schválení bylo ohlášeno 18. srpna 2014 a publikována byla jako ISO/IEC 14882:2014 v prosinci 2014.

Protože starší revize normy C++ se výrazně opozdily, byla verze C++17 někdy označována „C++1y“, podobně jako jako byla verze C++11 označována „C++0x“. V roce 2017 byla nahrazena normou C++17.

Nové vlastnosti jazyka

K jádru jazyka C++ byly ve verzi C++14 přidány následující vlastnosti:

Vyvozování návratového typu funkce

C++11 umožňuje odvodit návratový typ lambda funkce z typu výrazu použitého v příkazu return. C++14 tuto schopnost rozšiřuje na všechny funkce. Pro lambda funkce lze návratový typ vyvodit i pro funkce, které nejsou tvaru return výraz.

Pro použití vyvozování návratového typu musí být funkce deklarována s návratovým typem auto, a nesmí být použit koncový specifikátor návratového typu zavedený v C++11:

auto DeduceReturnType(); // návratový typ, který se má odvodit.

Pokud je v implementaci funkce použito několik návratových výrazů, pak se ze všech musí odvodit stejný typ.

Funkce, u nichž je použito vyvozování návratového typu, mohou být deklarovány dopředně, ale dokud nebyly definovány, nemohou být použity. Jejich definice musí být dostupná v té kompilační jednotce, v níž jsou použity.

Funkce tohoto typu mohou používat rekurzi, ale rekurzivní volání se může objevit až po příkazu return v definici funkce:

auto Correct(int i)
{
  if (i == 1)
    return i; // návratový typ odvozený jako int

  return Correct(i-1)+i; // Rekurzivní volání je zde v pořádku
}

auto Wrong(int i)
{
  if (i != 1)
    return Wrong(i-1)+i; // Tomuto volání nepředchází příkaz return -> chyba

  return i; // návratový typ odvozený jako int
}

Alternativní vyvozování typu při deklaraci

C++11 definovalo dvě metody vyvozování typu: auto umožňuje deklarovat proměnnou, jejíž typ se odvodí z typu výrazu, kterým je inicializována. Operátor decltype vrací typ daného výrazu při překladu. Tyto dvě metody však vyvozují typ různými způsoby. Konkrétně auto nikdy nevyvodí referenci, jako při použití std::decay, zatímco auto&& vždy vyvodí referenci. Operátor decltype lze však přimět k vyvození reference nebo nereference na základě kategorie hodnoty výrazu a povahy výrazu:

int i;
int&& f();
auto x3a = i;            // decltype(x3a) je int
decltype(i) x3d = i;     // decltype(x3d) je int
auto x4a = (i);          // decltype(x4a) je int
decltype((i)) x4d = (i); // decltype(x4d) je int&
auto x5a = f();          // decltype(x5a) je int
decltype(f()) x5d = f(); // decltype(x5d) je int&&

C++14 umožňuje použít decltype(auto), což umožňuje, aby deklarace s auto používaly stejná pravidla, jaká používá decltype.

Syntaxe decltype(auto) může být použita také s vyvozováním návratového typu funkce.

Uvolnění omezení pro constexpr

Verze C++11 zavedla koncept funkcí deklarovaných s constexpr, u nichž lze hodnotu zjistit v době překladu. Návratovou hodnotu takové funkce lze použít v konstantním výrazu, např. v celočíselném argumentu šablony. V C++11 mohly funkce s constexpr obsahovat pouze jediný výraz, které je vracené (stejně jako static_assert a několik dalších deklarací).

C++14 tato omezení uvolňuje. Funkce deklarované s constexpr mohou nyní obsahovat:

• libovolné deklarace kromě:
  • deklarací proměnných se static nebo thread_local
  • deklarací proměnných bez inicializátorů
• příkazů podmíněného větvení if a switch
• libovolných příkazů cyklu, včetně cyklu přes rozsah
• výrazy, které mění hodnotu objektu, pokud životnost tohoto objektu začala ve funkce v konstantním výrazu; sem patří volání libovolných nestatických členských funkcí bez const nebo constexpr.

Ve funkcích deklarovaných s constexpr jsou zakázány příkazy goto.

Verze C++11 také vyžaduje, aby všechny nestatické členské funkce, které byly deklarovány s constexpr byly také implicitně deklarovány s const podle this. V C++14 bylo toto omezení odstraněno; nestatické členské funkce nemusí být const. Kvůli výše uvedenému omezení však constexpr členské funkce bez const mohou měnit členy třídy, pouze pokud životnost tohoto objektu začala ve vyhodnocování konstantního výrazu.

Šablony proměnných

V předchozích verzích C++ bylo možné definovat šablony pouze pro funkce, třídy nebo typové aliasy. C++14 umožňuje vytváření šablon proměnných. V návrhu je uveden příklad proměnné pi, kterou lze číst pro získání hodnoty Ludolfova čísla $\pi$ různých typů (například 3, pokud se čte jako celočíselný typ; lepší hodnotu lze získat pro typy float, double nebo long double).

Pro takové deklarace a definice platí obvyklá pravidla pro šablony, včetně specializací.

template<typenameT>
constexpr T pi = T(3.141592653589793238462643383);

// Obvyklý způsob specializace:
template<>
constexpr const char* pi<const char* > = „pi“;

Inicializace členů agregátů

Verze C++11 přidala implicitní inicializátory členů, výrazy, které se použijí na členy v rozsahu platnosti třídy, pokud konstruktor neinicializuje člen samotný. Definice agregátů byla změněna tak, aby výslovně vylučovala všechny třídy s inicializátory členů; proto se nesmějí používat pro inicializaci agregátů.

C++14 toto omezení uvolňuje, a umožňuje agregátní inicializaci takových typů. Pokud inicializační seznam uzavřený ve složených závorkách neobsahuje hodnotu určitého argumentu, postará se o ni členský inicializátor.

Binární literály

Numerické literály lze v C++14 zapisovat ve dvojkové soustavě s použitím předpony 0b nebo 0B, která se používá i v jiných jazycích, např. v Javě, C#, Swift, Go, Scala, Ruby, Python, OCaml, a jako neoficiální rozšíření v některých překladačích jazyka C již od roku 2007.

Oddělovače číslic

V C++14 lze používat znak apostrof jako oddělovač číslic v číselných literálech, jak v celočíselných, tak pro čísla s pohyblivou řádovou čárkou. Jeho použití může člověku usnadňovat analýzu dlouhých čísel:

auto integer_literal = 1'000'000; // milion
auto floating_point_literal = 0.000'015'3; // patnáct miliontin
auto binary_literal = 0b0100'1100'0110; // lze i skupiny po čtyřech číslicích
auto a_dozen_crores = 12'00'00'000;

Obecné lambda funkce

V C++11 musí být parametry lambda funkcí deklarovány s konkrétními typy. C++14 tento požadavek uvolňuje a dovoluje, aby parametry lambda funkcí byly deklarovány se specifikátorem typu auto.

auto lambda = [](auto x, auto y) {return x + y;};

Co se týče vyvozování typu auto, generické lambda funkce se řídí pravidly vyvozování argumentů šablon (která jsou podobná, ale ne ve všech směrech totožná^[ujasnit]). Výše uvedený kód je ekvivalentní s:

struct
{
  template<typenameT, typename U>
    auto operator()(T x, U y) const {return x + y;}
} lambda{};

Generické lambda funkce jsou v zásadě šablonové lambda funktory.

Lambda capture výrazy

Lambda funkce v C++11 zachycují proměnné deklarované v obklopujícím rozsahu platnosti kopírováním hodnot nebo referencí. To znamená, že hodnotové členy lambda funkce nemohou typy umožňující pouze přesun. C++14 umožňuje zachycené členy inicializovat libovolnými výrazy. To umožňuje jak zachycení pomocí přesunu hodnoty, tak deklaraci libovolných členů lambda funkce, aniž by v obklopujícím rozsahu platnosti existovala odpovídající pojmenovaná proměnná.

To se provádí pomocí inicializačního výrazu:

auto lambda = [hodnota = 1] {return hodnota;};

Lambda funkce lambda vrací hodnotu 1, na kterou byla proměnná hodnota inicializována. Deklarované zachycení vyvozuje typ z inicializačního výrazu, jako kdyby bylo použito auto.

To lze použít pro zachycení přesunem, použitím standardní funkce std::move:

std::unique_ptr<int> ptr(nový int(10));
auto lambda = [hodnota = std::přesun(ptr)] {return *hodnota;};

Atribut deprecated

Atribut deprecated umožňuje označit entitu jako deprecated (nedoporučovaná). Takovou entitu lze stále používat, ale při překladu může způsobit výpis varování, aby programátor věděl, že s jejím použitím se v budoucnu nepočítá. Atribut deprecated může být doplněn textem, který může obsahovat odůvodnění a napovídat, jakou použít náhradu.

[[deprecated]] int f();

[[deprecated("g() is thread-unsafe. Use h() instead")]]
void g( int& x );

void h( int& x );

void test()
{
  int = f(); // varování: 'f' is deprecated
  g(a); // varování: 'g' is deprecated: g() is thread-unsafe. Use h() instead
}

Nové vlastnosti standardní knihovny

Sdílené mutexy a zamykání

C++14 přidává sdílený časovaný mutex a doprovodný sdílený zámek.

Heterogenní vyhledávání v asociativních kontejnerech

Standardní knihovna C++ definuje čtyři třídy asociativních kontejnerů. Tyto třídy umožňují uživateli vyhledat hodnotu podle klíče daného typu. Kontejnery v jejichž názvu je slovo „anglicky map (zobrazení)“ umožňují uživateli zadat jak klíč tak hodnotu, přičemž vyhledávání se provádí podle klíče a vrací hodnotu. Vyhledávání se však vždy provádí podle určitého typu klíče, ať je to klíč jako u zobrazení nebo samotná hodnota jako u množin.

C++14 umožňuje vyhledávat podle libovolného typu, pokud pro něj existuje operátor porovnání. To umožňuje porovnávat klíče typu std::string s řetězci typu const char* nebo jiného typu, pro který existuje přetížení operátoru <. Také je užitečné indexovat složené objekty v std::set hodnotou jediného členu bez nutnosti vytvářet nastrčený objekt při používání funkce find (nebo např. nutné vytvářet celou struct Osoba pro hledání osoby podle jména).

Kvůli zachování zpětné kompatibility je heterogenní vyhledávání povoleno pouze tehdy, když to komparátor přiřazený k asociativnímu kontejneru umožňuje. Pro usnadnění heterogenního hledání bylo ve standardní knihovně provedeno rozšíření tříd std::less<> a std::greater<>.

Standardní uživatelem definované literály

C++11 definovalo syntaxi pro uživatelem definované sufixy literálů, ale standardní knihovna je nepoužívala. C++14 přidává následující standardní literály:

• s, pro vytváření různých typů založených na std::basic_string.
• h, min, s, ms, us, ns, pro vytváření odpovídajících std::chrono::duration časových intervalů.
• if, i, il, pro vytváření odpovídajících imaginárních čísel typu std::complex<float>, std::complex<double> nebo std::complex<long double>.

auto str = "hello world"s; // z auto se vyvodí string
auto dur = 60s;            // z auto se vyvodí chrono::seconds
auto z = 1i;               // z auto se vyvodí complex<double>

Existence dvou literálových sufixů s nepůsobí kolizi, protože jeden je řetězcový a druhý číselný.

Adresování prvků n-tic pomocí typu

Typ std::tuple zavedený v C++11 umožňuje indexovat n-tici typovaných hodnot pomocí celočíselného indexu, jehož hodnota je konstanta známá v době překladu. C++14 umožňuje také výběr hodnoty z n-tice podle typu. Pokud má n-tice více než jeden prvek daného typu, bude při překladu ohlášena chyba:

tuple<string, string, int> t(“foo“, „bar“, 7);
int i = get<int>(t);       // i == 7
int j = get<2>(t);         // Totéž: j == 7
string s = get<string>(t); // Chyba při překladu kvůli nejednoznačnost

Menší vlastnosti knihovny

Pro objekty std::unique_ptr lze používat std::make_unique jako std::make_shared.

K std::integral_constant bylo doplněno přetížení operator() pro vrácení konstantní hodnoty.

Pro reprezentaci celočíselných posloupností při překladu byla doplněna šablona třídy std::integer_sequence a příslušné aliasy např. pro indexy prvků v parametru pack.

Globální funkce std::begin/std::end byly doplněny o funkce std::cbegin/std::cend, které vracejí konstantní iterátory, a std::rbegin/std::rend a std::crbegin/std::crend který vracet inverzní iterátory.

Šablona funkce std::exchange přiřazuje proměnné novou hodnotu a vrací její původní hodnotu.

Nová přetížení std::equal, std::mismatch a std::is_permutation bere dvojici iterátorů pro druhý rozsah, tak, že volající nepotřebuje odděleně kontrolovat, že oba rozsahy mají stejnou délku.

Typový rys std::is_final detekuje, že třída je final.

Manipulátor vstupně-výstupního proudu std::quoted umožňuje vkládání a extrakci řetězců obsahujících mezery umísťováním oddělovačů (implicitně uvozovek) na výstupu a jejich odstraňováním na vstupu, a escapováním všech vestavěných oddělovačů.

Podpora překladačů

Clang dokončil podporu pro C++14 ve verzi 3.4 i když pod jménem C++1y, a od Clang 6 je chování podle C++14 implicitní. GCC dokončil podporu pro C++14 v GCC 5, a od GCC 6 je chování podle C++14 implicitní. Microsoft Vizuální Studio implementovalo „téměř všechny“ vlastnosti C++14 ve verzi 2017.

Odkazy

Reference

V tomto článku byl použit překlad textu z článku C++14 na anglické Wikipedii.

Externí odkazy

• C++14: What you need to know Přehled vlastností v Dr. Dobb's ze 16. září 2014
• ZEMEK, Petr. Co je nového v C++14 [online]. 2014-09-20 [cit. 2024-09-14]. Dostupné online.