Pokročilé programování v C++ (část B)

Pokročilé programování v C++ (část B)
David Bednárek

C++11 Jazyk Knihovny && (rvalue reference) Lambda auto
Variadic templates Inicializátory Knihovny

Policy class, traits

Šablony tříd - definice
Šablona je generická třída parametrizovaná libovolným počtem formálních parametrů těchto druhů: celé číslo – uvnitř šablony se chová jako konstanta, použitelná i jako meze polí ukazatel libovolného typu libovolný typ – deklarováno zápisem class T nebo typename T, identifikátor formálního parametru se chová jako identifikátor typu, použitelný uvnitř šablony v libovolné deklaraci Prefix definice šablony template< formální-parametry> lze použít před několika formami deklarací; oblastí platnosti formálních parametrů je celá prefixovaná deklarace

Šablony funkcí lze volat dvěma způsoby
Šablona funkce je generická funkce (globální nebo metoda) prefixovaná konstrukcí template se stejnými druhy formálních parametrů šablony jako u šablon tříd template< typename T, int k> // parametry šablony int f( T * p, int q); // parametry funkce template< typename T, typename U> // parametry šablony int g( T * p, vector q); // parametry funkce Šablony funkcí lze volat dvěma způsoby Explicitně f< int, 729>( a, b) Automaticky g( a, b) Překladač dopočte parametry šablony z typů parametrů funkce Všechny formální argumenty šablony by měly být užity v typech formálních parametrů funkce

Šablony s mnoha parametry vs. policy class
template< typename T, bool binary, bool cached> class File { // ... T get() { if ( binary ) } }; File< char, false, true> my_file; template< typename P> class File { // ... typename P::T get() { if ( P::binary ) } }; struct my_policy { typedef char T; static const bool binary = false; static const bool cached = true; File< my_policy> my_file;

Policy class Policy class
template< typename P> class File { // ... typename P::T get() { if ( P::binary ) } }; struct my_policy { typedef char T; static const bool binary = false; static const bool cached = true; File< my_policy> my_file; Policy class Třída (class/struct) použitá pouze jako parametr šablony Neexistuje objekt tohoto typu Obsahuje pouze typy (typedef/vnořené třídy) statické konstanty statické funkce Reference na typy z policy class jsou závislá jména a musejí mít prefix typename

Šablony tříd – závislé typy
Šablony tříd (včetně těl metod) se při deklaraci kontrolují pouze částečně Překladač může kontrolovat jen to, co nezávisí na parametru Některé překladače nedělají ani to Překladač potřebuje odlišit jména typů od ostatních jmen U jmen ve tvaru A::B to překladač někdy nedokáže Programátor musí pomoci klíčovým slovem typename template< typename T> class X { typedef typename T::B U; // T::B je typ typename U::D p; // T::B::D je typ typename Y<T>::C q; // Y<T>::C je typ void f() { T::D(); } // T::D není typ } typename je nutné uvést před jmény typu ve tvaru A::B, kde A je závislé jméno Závislé jméno je jméno obsahující přímo či nepřímo parametr šablony

Pokud je předkem třídy závislé jméno
Šablony tříd - this Pokud je předkem třídy závislé jméno překladač pak neví, které identifikátory jsou zděděny nedokáže realizovat přednost děděných před vnějšími uživatel musí pomoci konstrukcí this-> nebo kvalifikovaným jménem Pozor: Kvalifikované jméno vypíná virtuálnost funkce template< typename T> class X : public T { void f() { return m(); } // globální funkce m() void g() { return this->m(); } // metoda třídy T (nebo předka) void h() { return T::m(); } // metoda třídy T (nebo předka) }

Ekvivalence typů Při ekvivalenci typů rozhodují jména tříd/struktur
template< typename P> class File { // ... typename P::T get() { if ( P::binary ) } }; struct my_policy { typedef char T; static const bool binary = false; static const bool cached = true; File< my_policy> my_file; struct my_policy2 { typedef char T; static const bool binary = false; static const bool cached = true; }; void f( File< my_policy2> & p); f( my_file); // error Při ekvivalenci typů rozhodují jména tříd/struktur obsah typových konstrukcí včetně typedef my_policy a my_policy2 jsou různé typy, tudíž se liší i File< my_policy> a File< my_policy2>

Využití neekvivalence typů
template< typename P> class Value { typename P::T v; // ... }; struct mass { typedef double T; struct energy { Value< mass> m; Value< energy> e; e = m; // error Silná typová kontrola Odlišně pojmenované typy mají stejný obsah nejsou kompatibilní

Využití neekvivalence typů
template< typename P> class Value { double v; // ... }; struct mass {}; struct energy {}; Value< mass> m; Value< energy> e; e = m; // error Silná typová kontrola Odlišně pojmenované typy mají stejný obsah nejsou kompatibilní Lze použít i typy bez obsahu

Využití ekvivalence typů
template< int kg, int m, int s> class Value { double v; // ... }; template< int kg1, int m1, int s1, int kg2, int m2, int s2> Value< kg1+kg2, m1+m2, s1+s2> operator*( const Value< kg1, m1, s1> & a, const Value< kg2, m2, s2> & b); typedef Value< 1, 0, 0> Mass; typedef Value< 0, 1, -1> Velocity; typedef Value< 1, 2, -2> Energy; Mass m; Velocity c; Energy e; e = m * c * c; // OK Instance šablony Value se stejnými hodnotami číselných parametrů jsou ekvivalentní Konstrukce typedef je transparentní

Explicitní specializace
template< int kg, int m, int s> struct Unit { static void print( ostream & os) { os << ”kg^” << kg << ”.m^” << m << ”.s^” << s; } }; template<> struct Unit< 1, 2, -2> { os << ”J”; Generickou definici šablony lze překrýt jinou definicí pro speciální případ Jiná šablona pak může mírně měnit své chování template< int kg, int m, int s> ostream & operator<<( ostream & os, const Value< kg, m, s> & x) { os << x << “ “; Unit< kg, m, s>::print( os); return os; }

Parciální specializace
template< class X, class Y> class C { /* základní definice */ }; Parciální specializace Deklarovanou šablonu lze pro určité kombinace parametrů předefinovat jinak, než určuje její základní definice Parciální specializace může mít stejný, menší i větší počet formálních parametrů než základní definice, jejich hodnoty se odvozují ze skutečných parametrů šablony (kterých je vždy tolik, kolik určuje základní definice) template< class T, class U, int n> class C< T[n], U[n]> { /* specializace pro dvě pole stejné velikosti */ }; Explicitní specializace template<> class C< char, int[ 8]> { /* ... */ }; Explicitní specializace šablony není šablona Podléhá trochu jiným (jednodušším) pravidlům Překlad se neodkládá Těla metod se nemusí psát do hlavičkových souborů

Typická použití parciální a explicitní specializace Výhodnější implementace ve speciálních případech Programátor - uživatel šablony o specializaci nemusí vědět Příklad: Implementace vector<char> může být jednodušší Mírná změna rozhraní ve speciálních případech Uživatel by měl být o specializaci informován Příklad: vector< bool> nedovoluje vytvořit ukazatel na jeden prvek Modifikace chování jiné šablony - traits Specializovaná šablona je volána z jiného šablonovaného kódu Autor volající šablony předpokládá, že ke specializaci dojde Někdy dokonce ani nedefinuje základní obsah volané šablony Autor specializace tak upravuje chování volající šablony Příklad: šablona basic_string<T> volá šablonu char_traits<T>, ve které je např. definována porovnávací funkce Generické programování Výpočty (s celými čísly a typovými konstrukcemi) při překladu

Parciální specializace - traits
Modifikace chování jiné šablony - traits Specializovaná šablona je volána z jiného šablonovaného kódu Autor volající šablony předpokládá, že ke specializaci dojde Někdy dokonce ani nedefinuje základní obsah volané šablony Autor specializace tak upravuje chování volající šablony Příklad: šablona basic_string<T> volá šablonu char_traits<T>, ve které je např. definována porovnávací funkce template< class T> struct char_traits; template< class T> class basic_string { /* ... */ int compare( const basic_string< T> & b) const { /*...*/ char_traits< T>::compare( /* ... */) /*...*/ } }; template<> struct char_traits< char> { /* ... */ static int compare(const char* s1, const char* s2, size_t n) { return memcmp( s1, s2, n); }

Modifikace chování jiné šablony Specializovaná šablona je volána z jiného šablonovaného kódu Autor volající šablony předpokládá, že ke specializaci dojde Někdy dokonce ani nedefinuje základní obsah volané šablony Autor specializace tak upravuje chování volající šablony Traits Šablony, ze kterých nejsou vytvářeny objekty Obsahují pouze: Definice typů Konstanty Statické funkce Určeny k doplnění informací o nějakém typu Příklad: char_traits<T> doplňuje informace o typu T, např. porovnávací funkci

Šablony, ze kterých nejsou vytvářeny objekty Obsahují pouze:
Traits & policies Traits Šablony, ze kterých nejsou vytvářeny objekty Obsahují pouze: Definice typů Statické funkce Určeny k doplnění informací o nějakém typu Příklad: char_traits<T> doplňuje informace o typu T, např. porovnávací funkci Policy classes Třídy, ze kterých obvykle nejsou vytvářeny objekty Předávány jako parametr šablonám Defaultní hodnotou parametru často bývá šablona traits Určeny k definování určitého chování Příklad: Alokační strategie

Policy class vs. traits template< typename P, typename K>
void for_each( K & data) { for( ... it = ... ) P::f( * it); } struct policy_add { static void f(...) ... }; my_k data; for_each< policy_add>( data); template< typename K> struct for_each_traits; void for_each( K & data) { for( ... it = ... ) for_each_traits< K>::f( * it); } template<> struct for_each_traits< my_k> { static void f(...) ... }; my_k data; for_each( data);

Polymorfismus Kompilační a běhový

Stejný zdrojový kód v různých situacích dělá různé věci
Polymorfismus Polymorfismus Stejný zdrojový kód v různých situacích dělá různé věci Volání stejně pojmenované funkce (operátoru) volá různá těla Šetří práci programátora (zejména na údržbě) Kód není třeba kopírovat Nahrazuje konstrukce if/switch Kód je přehlednější a obsahuje méně chyb

Kompilační polymorfismus Šablony, zejména:
Funktory apod. Policy classes, traits Běhový polymorfismus C: ukazatele na funkce C++: dědičnost a virtuální funkce Běhový polymorfismus zdržuje Používat pouze v nutném případě Datové struktury obsahující objekty s různým chováním ("OOP") Komunikace s neznámými partnery (komponentové systémy) Vše ostatní lze řešit kompilačním polymorfismem

Polymorfismus běhový a kompilační
class functor { public: virtual void f( ...) = 0; }; void for_each( functor & x) { for( ... it = ... ) x.f( * it); // run-time binding } class functor_add : public functor { virtual void f(...) ... for_each( functor_add()); template< typename P> void for_each( P & x) { for( ... it = ... ) x.f( * it); // compile-time binding } struct functor_add { void f(...) ... }; for_each( functor_add());

Kompilační polymorfismus s objektem a bez
template< typename P> void for_each( P & x) { for( ... it = ... ) x.f( it); // metoda } struct functor_add { void f(...) ... }; for_each( functor_add()); template< typename P> void for_each() { for( ... it = ... ) P::f( it); // statická funkce } struct policy_add { static void f(...) ... }; for_each< policy_add>();

Generické programování
Výpočty při překladu

Teoretický pohled na šablony
Překladač dokáže vyhodnotit celočíselnou aritmetiku I s rekurzivními funkcemi template< int N> struct Fib { static const int value = Fib< N-1>::value + Fib< N-2>::value; }; template<> struct Fib< 0> { static const int value = 1; template<> struct Fib< 1> { Kontrolní otázka: Jak dlouho trvá výpočet (tj. kompilace) Fib< 1000>::value

Překladač dokáže vyhodnotit celočíselnou aritmetiku I s rekurzivními funkcemi template< int N> struct Fib { static const int value = Fib< N-1>::value + Fib< N-2>::value; }; template<> struct Fib< 0> { static const int value = 1; template<> struct Fib< 1> { Kontrolní otázka: Jak dlouho trvá výpočet (tj. kompilace) Fib< 1000>::value MS Visual C++ 7.1: Build Time 0:00 Kompilátory ukládají již vytvořené instanciace a nepočítají je znovu

C++11: <type_traits>
Triky s šablonami Podmíněný výraz nad typy template< bool C, typename A, typename B> struct conditional { typedef A type; }; template< typename A, typename B> struct conditional< false, A, B> { typedef B type; conditional< C, A, B>::type je typ Použití template< bool wide> class File { typename conditional< wide, wchar_t, char>::type get(); /* ... */ C++11: <type_traits>

C++11: <type_traits>
Triky s šablonami Porovnání typů s booleovským výstupem template< class A, class B> struct is_same { static const bool value = false; }; template< class A> struct is_same< A, A> { static const bool value = true; is_same< X, Y>::value je konstantní výraz Použití template< class T1> class Test { static const bool very_long = is_same< long long, T1>::value; typedef conditional< is_long, unsigned long long, unsigned long> T; /* ... */ C++11: <type_traits>

C++11: vestavěno v jazyce
Triky s šablonami Kompilační ověření invariantu template< bool x> struct static_assert { struct type {}; }; template<> struct static_assert< false> { template< int x> struct Assert { typename static_assert< (x > 0)>::type ignore_me(); static_assert( x > 0); C++11: vestavěno v jazyce

Variadic templates

Šablony s proměnlivým počtem parametrů
Hlavička šablony s proměnlivým počtem typových argumentů template< typename ... TList> class C { /* ... */ }; pojmenovaný parametr zastupující seznam typů lze i kombinovat s pevnými parametry template< typename T1, int c2, typename ... TList> class D { /* ... */ }; platí i pro hlavičky parciálních specializací template< typename T1, typename ... TList> class C< T1, TList ...> { /* ... */ }; C++11

template< typename ... TList> pojmenovaný parametr - seznam typů lze uvnitř šablony použít v těchto konstrukcích: vždy se suffixem ... typové argumenty v použití (jiné) šablony X< TList ...> Y< int, TList ..., double> seznam předků třídy class E : public TList ... deklarace parametrů funkce/metody/konstruktoru void f( TList ... plist); double g( int a, TList ... b, double c); tím vzniká pojmenovaný parametr zastupující seznam hodnot několik dalších okrajových případů C++11

template< typename ... TList> void f( TList ... plist); pojmenovaný parametr - seznam hodnot lze uvnitř funkce použít v těchto konstrukcích: vždy se suffixem ... hodnotové argumenty ve volání (jiné) funkce/konstruktoru g( plist ...) new T( a, plist ..., 7) T v( b, plist ..., 8); inicializační sekce konstruktoru E( TList ... plist) : TList( plist) ... { } několik dalších případů C++11

template< typename ... TList> void f( TList ... plist); při použití je možno prvky seznamu obalit suffix ... slouží jako kompilační for_each (každý) výskyt názvu seznamu je nahrazen jeho i-tým prvkem výsledkem je seznam typů X< std::pair< int, TList *> ...> class E : public U< TList> ... void f( const TList & ... plist); seznam výrazů ve volání funkce/metody/konstruktoru g( make_pair( 1, & plist) ...); h( static_cast< TList *>( plist) ...); i( sizeof( TList) ...); seznam inicializátorů v konstruktoru další okrajové případy C++11

Generická N-tice použití
template <class ... Types> class tuple { public: tuple( const Types & ...); /* ... */ }; template < size_t I, class T> class tuple_element { typedef /* ... */ type; template < size_t I, class ... Types> typename tuple_element< I, tuple< Types ...> >::type & get( tuple< Types ...> & t); použití tuple< int, double, int> t1( 1, 2.3, 4); double v = get< 1>( t1); C++11: <utility>

Rvalue reference Francisco de Goya. Sv. František Borgiáš u lože umírajícího (detail)

Doplnění rvalue referencí do standardních knihoven
Rvalue reference Rvalue reference Nová typová konstrukce T && Lvalue reference Nový název pro starou typovou konstrukci T & Doplnění rvalue referencí do standardních knihoven Cíl: Zrychlit běh existujících zdrojových kódů Existující zdrojové kódy musí zůstat použitelné bez úprav Přidány nové funkce umožňující další zrychlení Rvalue reference mění styl programování v C++ Konstrukce dříve neefektivní se stávají použitelnými Použití nových knihovních funkcí Přímé použití rvalue referencí Move semantika - umožňuje nové druhy ukazatelů

Srozumitelný způsob použití
Rvalue reference Rvalue reference Jasná motivace Odstranění nadbytečných kopírování Srozumitelný způsob použití Kanonické tvary tříd Nové knihovní funkce Složitá definice lvalue, xvalue, prvalue, glvalue, rvalue reference collapsing rules Nedozírné následky Princip navržen v r. 2002 Ještě v r odstraňována nevhodná vylepšení z návrhu normy Byla to všechna?

Třídy obsahující velká data
Motivace pro rvalue reference

Matrix - Řešení bez rvalue referencí
class Matrix { public: Matrix(); Matrix( const Matrix & b); const Matrix & operator=( const Matrix & b); ~Matrix(); Matrix & operator+=( const Matrix & b) const; /* ... */ private: double * data_; std::size_t vsize_, hsize_; }; inline Matrix operator+( const Matrix & a, const Matrix & b) { Matrix t( a); t += b; return t; }

Poučení - konstruktory
Ve třídě Matrix jsou odkazy na data uložená jinde Chování kompilátorem vytvořených metod nevyhovuje: Matrix(); Nedělá nic - je třeba alespoň vynulovat nebezpečné položky Matrix( const Matrix &); Kopíruje ukazatel - je třeba kopírovat data, na která ukazuje Matrix & operator=( const Matrix &); Totéž, navíc je nutné před přiřazením uklidit ~Matrix(); Nedělá nic - je třeba uklidit Tyto metody je tedy třeba napsat vlastní

Operátor přiřazení by měl udělat toto:
Poučení - operator= Operátor přiřazení by měl udělat toto: Zrušit starý obsah levé strany Totéž co destruktor Okopírovat pravou stranu Totéž co konstruktor Vrátit novou hodnotu levé strany To lze vrátit odkazem Pozor - v některých případech to takto fungovat nebude: Matrix a; std::vector< Matrix> b; /* ... */ a = a; b[ i] = b[ j]; Při kopírovaní pravá strana už nebude existovat

Amatérské řešení operátoru přiřazení:
Poučení - operator= Amatérské řešení operátoru přiřazení: Matrix & Matrix::operator=( const Matrix & b) { if ( this != & b ) { clean(); fill( b); } return * this; Konstruktory nelze přímo volat, u destruktoru to není rozumné Matrix::Matrix( const Matrix & b) Matrix::~Matrix() clean();

Lepší řešení operátoru přiřazení:
Poučení - operator= Lepší řešení operátoru přiřazení: #include <algorithm> void Matrix::swap_with( Matrix & b) { swap( data_, b.data_); swap( xsize_, b.ysize_); swap( ysize_, b.ysize_); } Matrix & Matrix::operator=( const Matrix & b) Matrix tmp( b); swap_with( tmp); return * this; Toto řešení je navíc exception-safe (později...) Metodu swap je vhodné publikovat takto void swap( Matrix & a, Matrix & b) { a.swap_with( b); } Algoritmy (např. sort) používají swap a tento je rychlejší než generický

před C++11 Poučení - operator+ operator + vrací novou hodnotu
v okamžiku návratu nikde jinde není je nutné vracet hodnotou Matrix operator+( const Matrix & a, const Matrix & b) vracení hodnotou znamená volání copy-constructoru data se kopírují, mnohdy zbytečně Matrix a, b, c, d; a = b + c + d; před C++11

před C++11 Poučení - operator+ Vracení hodnotou
konstruuje pomocný objekt Matrix operator+( const Matrix & x, const Matrix & y); Matrix a, b, c, d; a = b + c + d; implementováno předáním ukazatele na volné místo void operator+( Matrix * rp, const Matrix * xp, const Matrix * yp); Matrix t1, t2; // bez volání konstruktoru operator+( & t1, & b, & c); operator+( & t2, & t1, & d); Matrix::operator=( & a, & t2); Matrix::~Matrix( & t2); Matrix::~Matrix( & t1); před C++11

před C++11 Poučení - operator+ implementováno předáním ukazatele
Matrix operator+( const Matrix & x, const Matrix & y) { Matrix t( x); t += y; return t; } implementováno předáním ukazatele void operator+( Matrix * rp, const Matrix * xp, const Matrix * yp) Matrix t; // bez volání konstruktoru Matrix::Matrix( & t, xp); Matrix::operator+=( & t, yp); Matrix::Matrix( rp, & t); Matrix::~Matrix( & t); před C++11

před C++11 Poučení - operator+ implementováno takto: a = b + c + d;
Matrix t1, t2, t3, t4, t5; // bez volání konstruktoru // operator+( & t1, & b, & c); Matrix::Matrix( & t3, & b); // kopie #1 Matrix::operator+=( & t3, & c); Matrix::Matrix( & t1, & t3); // kopie #2 Matrix::~Matrix( & t3); // operator+( & t2, & t1, & d); Matrix::Matrix( & t4, & t1); // kopie #3 Matrix::operator+=( & t4, & d); Matrix::Matrix( & t2, & t4); // kopie #4 Matrix::~Matrix( & t4); // Matrix::operator=( & a, & t2); Matrix::Matrix( & t5, & t2); // kopie #5 Matrix::swap( & a, & t5); Matrix::~Matrix( & t5); Matrix::~Matrix( & t2); Matrix::~Matrix( & t1); před C++11

před C++11 Poučení - operator+ šikovný překladač eliminuje proměnnou t
Matrix operator+( const Matrix & x, const Matrix & y) { Matrix t( x); t += y; return t; } šikovný překladač eliminuje proměnnou t pozorovatelná změna chování programu, povoleno normou void operator+( Matrix * rp, const Matrix * xp, const Matrix * yp) Matrix::Matrix( rp, xp); Matrix::operator+=( & t, yp); před C++11

před C++11 Poučení - operator+ po eliminaci t3, t4: a = b + c + d;
Matrix t1, t2, t5; // bez volání konstruktoru // operator+( & t1, & b, & c); Matrix::Matrix( & t1, & b); // kopie #1 Matrix::operator+=( & t1, & c); // operator+( & t2, & t1, & d); Matrix::Matrix( & t2, & t1); // kopie #2 Matrix::operator+=( & t2, & d); // Matrix::operator=( & a, & t2); Matrix::Matrix( & t5, & t2); // kopie #3 Matrix::swap( & a, & t5); Matrix::~Matrix( & t5); Matrix::~Matrix( & t2); Matrix::~Matrix( & t1); před C++11

před C++11 Poučení - operator+
Matrix & Matrix::operator=( Matrix b) { swap_with( b); return * this; } chytrý programátor a chytrý překladač dokážou eliminovat t5: Matrix t1, t2; // bez volání konstruktoru // operator+( & t1, & b, & c); Matrix::Matrix( & t1, & b); // kopie #1 Matrix::operator+=( & t1, & c); // operator+( & t2, & t1, & d); Matrix::Matrix( & t2, & t1); // kopie #2 Matrix::operator+=( & t2, & d); // Matrix::operator=( & a, & t2); Matrix::swap( & a, & t2); Matrix::~Matrix( & t2); Matrix::~Matrix( & t1); kopie t1 -> t2 je stále zbytečná před C++11

před C++11 Poučení - operator+
Matrix operator+( Matrix x, const Matrix & y) { x += y; return x; } nepomůže, potřebuje t3 pro x z prvního volání Matrix t1, t2, t3; // bez volání konstruktoru Matrix::Matrix( & t3, & b); // kopie #1 // operator+( & t1, & t3, & c); Matrix::operator+=( & t3, & c); Matrix::Matrix( & t1, & t3); // kopie #2 // operator+( & t2, & t1, & d); Matrix::operator+=( & t1, & d); Matrix::Matrix( & t2, & t1); // kopie #3 // Matrix::operator=( & a, & t2); Matrix::swap( & a, & t2); Matrix::~Matrix( & t2); Matrix::~Matrix( & t3); Matrix::~Matrix( & t1); před C++11

Řešení pomocí rvalue referencí
Zbytečná kopírování Řešení pomocí rvalue referencí

C++11 Řešení – operator= Princip řešení - operator= Dvě různé situace
a = b; zde se hodnota b okopírovat musí a = c + d; výsledek operátoru + se stane novou hodnotou a kopie principiálně není zapotřebí C++11

C++11 Řešení – operator= Princip řešení - operator= Dvě různé situace
Potřebujeme dvě implementace operatoru = a = b; zde se hodnota b okopírovat musí T & T::operator=( const T & x); copy-assignment objekt b bude pouze čten a = c + d; výsledek operátoru + se stane novou hodnotou a T & T::operator=( T && x); move-assignment hodnota vrácená operátorem + bude přesunuta do a zdrojový pomocný objekt bude přesunem modifikován C++11

C++11 Řešení – inicializace Totéž platí pro inicializaci
Dvě různé situace Potřebujeme dvě implementace konstruktoru T a = b; zde se hodnota b okopírovat musí T::T( const T & x); copy-constructor objekt b bude pouze čten T a = c + d; výsledek operátoru + se stane hodnotou a T::T( T && x); move-constructor hodnota vrácená operátorem + bude přesunuta do a zdrojový pomocný objekt bude přesunem modifikován C++11

Speciální metody tříd – C++11
copy/move Speciální metody tříd – C++11

C++11 copy/move Speciální metody tříd Copy constructor
T( const T & x); Move constructor T( T && x); Copy assignment operator T & operator=( const T & x); Move assignment operator T & operator=( T && x); C++11

C++11 copy/move Překladačem definované chování (default)
Copy constructor T( const T & x) = default; aplikuje copy constructor na složky Move constructor T( T && x) = default; aplikuje move constructor na složky Copy assignment operator T & operator=( const T & x) = default; aplikuje copy assignment operator na složky Move assignment operator T & operator=( T && x) = default; aplikuje move assignment operator na složky default umožňuje vynutit defaultní chování C++11

C++11 copy/move Podmínky automatického defaultu
Copy constructor/assignment operator pokud není explicitně deklarován move constructor ani assignment operator budoucí normy pravděpodobně zakážou automatický default i v případě přítomnosti druhé copy metody nebo destruktoru Move constructor/assignment operator pokud není deklarována žádná ze 4 copy/move metod ani destruktor C++11

C++11 copy/move Nejběžnější kombinace Neškodná třída
Nedeklaruje žádnou copy/move metodu ani destruktor Neobsahuje složky vyžadující zvláštní péči (ukazatele) Složky vyžadující zvláštní péči Překladačem generované chování (default) nevyhovuje Bez podpory move (před C++11) T( const T & x); T & operator=( const T & x); ~T(); Plná podpora copy/move T( T && x); T & operator=( T && x); C++11

C++11 copy/move Další kombinace Nekopírovatelná třída
Např. dynamicky alokované živé objekty v simulacích T( const T & x) = delete; T & operator=( const T & x) = delete; delete zakazuje generování překladačem Destruktor může ale nemusí být nutný Přesouvatelná nekopírovatelná třída Např. unikátní vlastník jiného objektu (viz std::unique_ptr) T( T && x); T & operator=( T && x); ~T(); Pravidla jazyka zakazují generování copy metod překladačem Destruktor typicky bývá nutný C++11

Řešení podle C++11

Matrix - Řešení s podporou move
class Matrix { public: Matrix(); Matrix( const Matrix & x); Matrix( Matrix && x); Matrix & operator=( const Matrix & x); Matrix & operator=( Matrix && x); ~Matrix(); /* ... */ private: double * data_; std::size_t vsize_, hsize_; }; Default nevyhovuje Copy metody musejí alokovat nová data_ Destruktor musí dealokovat data_ Move metody musejí vynulovat položku data_ ve zdroji rvalue reference neznamená, že zdroj nebude destruován Assignment operátory musejí nějak uklidit starý obsah C++11

Matrix – copy metody a destruktor
Matrix::Matrix( const Matrix & x) : data_( new double[ x.vsize_ * x.hsize_]), vsize_( x.vsize_), hsize_( x.hsize_) { std::copy( x.data_, x.data_ + vsize_ * hsize_, data_); } Matrix & Matrix::operator=( const Matrix & x) Matrix t( x); t.swap_with( * this); return * this; Trik s eliminací proměnné t v operátoru = nelze použít Hodnotou předávaný parametr by zastínil move assignment Matrix::~Matrix() delete data_; Operátor delete je odolný proti nulovému ukazateli C++11

C++11 Matrix – move metody
Matrix::Matrix( Matrix && x) : data_( x.data_), vsize_( x.vsize_), hsize_( x.hsize_) { x.data_ = nullptr; } x.data_ je nutné vynulovat – jinak je destruktor x dealokuje nullptr je nový preferovaný způsob zápisu nulového ukazatele Matrix & Matrix::operator=( Matrix && x) x.swap_with( * this); return * this; Stará hodnota * this se dostane do x Destruktor x ji časem zneškodní C++11

Matrix – move metody - varianta
Matrix::Matrix( Matrix && x) : data_( x.data_), vsize_( x.vsize_), hsize_( x.hsize_) { x.data_ = nullptr; } x.data_ je nutné vynulovat – jinak je destruktor x dealokuje nullptr je nový preferovaný způsob zápisu nulového ukazatele Matrix & Matrix::operator=( Matrix && x) Matrix t( std::move( x)); t.swap_with( * this); return * this; std::move vynutí move constructor pro inicializaci t Stará hodnota * this se dostane do t Destruktor t ji včas zneškodní C++11

lvalue/rvalue Pravidla

C++11 lvalue/rvalue U výrazu překladač zkoumá Lvalue typu T
Typ (po odstranění vnějších referencí) Kategorie - lvalue/rvalue T x; T * p; T & lr; T && rr; T f(); T & lrf(); T && rrf(); Lvalue typu T K objektu je možné přistupovat opakovaně (má jméno) Pozor: pojmenovaná rvalue reference je lvalue! x, * p, lr, rr, lrf() Rvalue typu T Tento výraz je jediná možnost přístupu k objektu Následovat bude už jen volání destruktoru f(), rrf(), std::move( x), std::move( rr) Číselné a znakové konstanty jsou rvalue Toto je zjednodušená definice Norma definuje lvalue, xvalue, prvalue, glvalue a rvalue C++11

C++11 lvalue/rvalue Pravidla předávání parametrů
Kategorie a typ výrazu lvalue rvalue T const T Typ parametru T, const T OK T & OK (+) --- const T & OK (-) T && const T && OK (+) má přednost před OK (-) Preferované případy, neobvyklé případy Platí i pro inicializaci proměnných a příkaz return Vše ostatní je jen volání funkcí a operátorů Zjednodušeno Skutečná pravidla jsou komplikována existencí dalších konverzí (předek-potomek, číselné konverze, uživatelské konverze, pole, funkce, ...)

Operátory podle C++11

class Matrix { public: Matrix(); Matrix( const Matrix & x); Matrix( Matrix && x); Matrix & operator=( const Matrix & x); Matrix & operator=( Matrix && x); ~Matrix(); Matrix & operator+=( const Matrix & b) const; /* ... */ private: double * data_; std::size_t vsize_, hsize_; }; Matrix operator+( const Matrix & a, const Matrix & b); Matrix && operator+( Matrix && a, const Matrix & b); Matrix && operator+( const Matrix & a, Matrix && b); Matrix && operator+( Matrix && a, Matrix && b); C++11

Matrix operator+( const Matrix & a, const Matrix & b) { return Matrix( a) += b; } Matrix && operator+( Matrix && a, const Matrix & b) return std::move( a += b); Matrix && operator+( const Matrix & a, Matrix && b) return std::move( b += a); Matrix && operator+( Matrix && a, Matrix && b) C++11

lvalue/rvalue Nové rozhraní STL

C++11 lvalue/rvalue - STL Nová implementace swap move
void swap( T & a, T & b) { T tmp( std::move( a)); a = std::move( b); b = std::move( tmp); } Není nutné specializovat swap pro uživatelské typy Postačí implementace move-metod move std::move( b); Zkratka za: static_cast< T &&>( b); C++11

C++11 lvalue/rvalue - STL Copy/move insertion Emplace
iterator insert( const_iterator p, const T & x); iterator insert( const_iterator p, T && x); Druhá verze umožňuje efektivní přesun hodnoty Týká se i push_back/push_front Emplace template< typename ... TList> iterator emplace( const_iterator p, TList && ... plist); Zkonstruuje objekt přímo na místě plist se předá jako parametry konstruktoru Existuje i emplace_back/emplace_front Další optimalizace uvnitř implementace kontejnerů Realokace vektoru používá move namísto copy C++11

lvalue/rvalue Perfect forwarding

C++11 Perfect forwarding new( q) je starý trik: placement new
template< typename ... TList> iterator emplace( const_iterator p, TList && ... plist) { void * q = /* místo pro nový prvek */; pointer r = new( q) value_type( plist ...); /* ... */ } new( q) je starý trik: placement new využívá možnost napsat si vlastní alokátor s parametrem navíc void * operator new( std::size, void * q) { return q; } C++11

C++11 Perfect forwarding Jak dokáže emplace předat parametry?
template< typename ... TList> iterator emplace( const_iterator p, TList && ... plist) { void * q = /* místo pro nový prvek */; pointer r = new( q) value_type( plist ...); /* ... */ } Jak dokáže emplace předat parametry? Co když je skutečným parametrem lvalue? Proč neexistuje verze s const TList & Bylo by jich exponenciálně mnoho! C++11

C++11 Perfect forwarding Trik: Skládání referencí
Jazyk definuje tato pravidla Použijí se u šablon funkcí s parametrem typu T && template< typename T> void f( T && p); X lv; f( lv); Parametr typu T && lze navázat na lvalue typu X Dosadí se T = X & f( std::move( lv)); Je-li skutečným parametrem rvalue typu X Dosadí se T = X C++11 X & & X & X && & X & && X && && X &&

C++11 Perfect forwarding Forwarding
template< typename T> void f( T && p) { g( p); } X lv; f( lv); Parametr typu T && lze navázat na lvalue typu X Dosadí se T = X & f( std::move( lv)); Je-li skutečným parametrem rvalue typu X Dosadí se T = X Parametr p je však lvalue Do funkce g by měl být předán pomocí std::move C++11

C++11 Perfect forwarding Perfect forwarding
template< typename T> void f( T && p) { g( std::forward< T>( p)); } std::forward< T> vrací T && X lv; f( lv); T = X & skládání referencí zajistí, že std::forward< T> vrací X & f( std::move( lv)); T = X std::forward< T> vrací X && v tomto případě se std::forward< T> chová jako std::move C++11

C++11 Perfect forwarding Správná implementace emplace
template< typename ... TList> iterator emplace( const_iterator p, TList && ... plist) { void * q = /* místo pro nový prvek */; pointer r = new( q) value_type( std::forward< TList>( plist) ...); /* ... */ } C++11

Smart pointers

C++11 Smart pointers Chytré ukazatele Výlučné vlastnictví
Automatické uvolnění dynamicky alokovaného objektu Jinak se chovají jako T * Operátory *, -> Porovnání ukazatelů, nullptr Výlučné vlastnictví Vyžaduje move-semantiku std::unique_ptr< T> Varianta pro pole: Operátor [] namísto * a -> std::unique_ptr< T[]> Sdílené vlastnictví Založeno na počítání odkazů std::shared_ptr< T> Vedlejší odkaz, který se nepočítá (počítání zdržuje) std::weak_ptr< T> Lze povýšit na shared_ptr, jinak je ekvivalentní s T * C++11

C++11 Smart pointers Výlučné vlastnictví Sdílené vlastnictví {
std::unique_ptr< T> q; // obsahuje nullptr std::unique_ptr< T> p = new T( /*...*/); q = std::move( p); } q->f(); h( * q); } // zde zaniká q i objekt T Sdílené vlastnictví std::shared_ptr< T> q; // obsahuje nullptr std::shared_ptr< T> p = std::make_shared< T>( /*...*/); q = p; // zde se zvětšuje čítač p->f(); } // zde se zmenšuje čítač std::weak_ptr< T> r = q; h( * r); C++11

Lambda

C++11 Lambda výrazy Motivace Řešení class ftor { public:
ftor(int a, int b) : a_(a),b_(b) { } bool operator()(int x) const { return x*a_<b_; } private: int a_, b_; }; typedef std::vector<int> v_t; v_t v; v_t::iterator vi=remove_if(v.begin(), v.end(), ftor(m, n)); Řešení std::vector<int> v; auto vi=remove_if(v.begin(), v.end(), [=](int x){ return x*m<n; }); C++11

C++11 Lambda výrazy Lambda výraz Deklaruje třídu ve tvaru
[ capture ]( params ) mutable -> rettype { body } Deklaruje třídu ve tvaru class ftor { public: ftor( TList ... plist) : vlist( plist) ... { } rettype operator()( params ) const { body } private: TList ... vlist; }; vlist je určen proměnnými použitými v body TList je určen jejich typy a upraven podle capture operator() je const pokud není uvedeno mutable Lambda výraz je nahrazen vytvořením objektu ftor( vlist ...) C++11

Lambda výrazy – návratový typ a typ funkce
Návratový typ operátoru Explicitně definovaný návratový typ []() -> int { … } Automaticky určen pro tělo lambda funkce ve tvaru []() { return V; } Jinak void C++11

Lambda výrazy – capture
[ capture ]( params ) mutable -> rettype { body } Způsob zpřístupnění vnějších entit Určuje typy datových položek a konstruktoru funktoru Explicitní capture Programátor vyjmenuje všechny vnější entity v capture [a,&b,c,&d] entity označené & předány odkazem, ostatní hodnotou Implicitní capture Překladač sám určí vnější entity, capture určuje způsob předání [=] [=,&b,&d] předání hodnotou, vyjmenované výjimky odkazem [&] [&,a,c] předání odkazem, vyjmenované výjimky hodnotou C++11

Lambda výrazy – příklad
int a = 1, b = 1, c = 1; auto m1 = [a, &b, &c]() mutable { auto m2 = [a, b, &c]() mutable { std::cout << a << b << c; a = 4; b = 4; c = 4; }; a = 3; b = 3; c = 3; m2(); a = 2; b = 2; c = 2; m1(); Co to vypíše? C++11 123234

Pokročilý pohled na kontejnery

Kontejnery a iterátory
Standardní knihovna definuje Mnoho druhů kontejnerů basic_string, vector, deque, list array, forward_list map, multimap, set, multiset unordered_map, unordered_multimap, unordered_set, unordered_multiset Odlišné přidávání/odebírání Shodný způsob procházení Každý kontejner definuje Typy iterator, const_iterator Metody begin(), end() Iterátory jsou inspirovány ukazatelovou aritmetikou Ukazatele do pole se chovají jako iterátory Algoritmy mohou pracovat s iterátory libovolného kontejneru s ukazateli do pole s čímkoliv, co má potřebné operátory void clr( int & x) { x = 0; } std::vector< int> v; for_each( v.begin(), v.end(), clr); std::array< int, N> a; for_each( a.begin(), a.end(), clr); int p[ N]; for_each( p, p + N, clr); C++11 C++11

Kategorie iterátorů Standardní knihovna definuje
Algoritmy mohou pracovat s čímkoliv, co má potřebné operátory Různé algoritmy mají různé nároky Norma C++ definuje 5 kategorií iterátorů random_access bidirectional forward output input Kategorie určuje, které syntaktické konstrukce musí iterátor umožňovat všechny kategorie iterator(I) /* copy constructor */ ++I, I++ output *I = x, *I++ = x random_access, bidirectional, forward, input I1 = I2 I1 == I2, I1 != I2 I->m /* pokud existuje (*I).m */ input *I /* pouze pro čtení */ random_access, bidirectional, forward iterator() *I /* čtení i zápis */ random_access, bidirectional --I, I-- random_access I += n, I + n, n + I I -= n, I - n, I1 - I2 I[ n] I1 < I2, I1 > I2, I1 <= I2, I1 >= I2

Použití iterátorů Pravidla použití iterátorů
Procházený rozsah bývá zadán intervalem [b,e) Dereferencovat e se nesmí Přebíhat za e/před b se nesmí template< iterator> void f( iterator b, iterator e) { ... = * b; // chyba ! for ( iterator i = e - 1; // chyba ! i >= b; -- i) // chyba ! ... }

Standardem definované iterátory
Iterátory na kontejnerech random_access category iterátory k vector a deque forward category iterátory k forward_list bidirectional category iterátory ostatních kontejnerů reverse_iterator šablona pro otočení smyslu bidirectional/random_access iterátoru kontejnery mají rbegin()/rend() pozor: k.rbegin() != reverse_iterator( k.end()) Falešné iterátory output category back_inserter, front_inserter, inserter std::vector a; std::copy( x.begin(), x.end(), std::back_inserter( a)); ostream_iterator std::ostream & o = ...; std::ostream_iterator( o)); input category istream_iterator std::istream & i = ...; std::copy( std::istream_iterator( i), std::istream_iterator(),

iterator_traits Složitější algoritmy
Potřebují znát typ, na který iterátor ukazuje, apod. Potřebují určit kategorii iterátoru Standard definuje šablonu iterator_traits parametrizovanou typem iterátoru Každý iterator ji musí definovat Obvykle nepřímo definováním těchto typů uvnitř třídy iterátoru Pokud to nejde, explicitní specializací šablony template<class Iterator> struct iterator_traits { typedef typename Iterator::difference_type difference_type; typedef typename Iterator::value_type value_type; typedef typename Iterator::pointer pointer; typedef typename Iterator::reference reference; typedef typename Iterator::iterator_category iterator_category; }; template<class T> struct iterator_traits<T*> { typedef ptrdiff_t difference_type; typedef T value_type; typedef T* pointer; typedef T& reference; typedef random_access_iterator_tag iterator_category;

Exception handling Mechanismus výjimek

Exception-safe programming
Používat throw a catch je jednoduché Těžší je programovat běžný kód tak, aby se choval korektně i za přítomnosti výjimek Exception-safety Exception-safe programming void f() { int * a = new int[ 100]; int * b = new int[ 200]; g( a, b); delete[] b; delete[] a; } Pokud new int[ 200] způsobí výjimku, procedura zanechá naalokovaný nedostupný blok Pokud výjimku vyvolá procedura g, zůstanou dva nedostupné bloky

Používat throw a catch je jednoduché Těžší je programovat běžný kód tak, aby se choval korektně i za přítomnosti výjimek Exception-safety Exception-safe programming T & operator=( const T & b) { if ( this != & b ) delete body_; body_ = new TBody( b.length()); copy( body_, b.body_); } return * this; Pokud new TBody způsobí výjimku, operátor= zanechá v položce body_ původní ukazatel, který již míří na dealokovaný blok Pokud výjimku vyvolá procedura copy, operátor zanechá třídu v neúplném stavu

Pravidla vynucená jazykem Destruktor nesmí skončit vyvoláním výjimky Výjimka může být vyvolána uvnitř, ale musí být zachycena nejpozději uvnitř destruktoru Zdůvodnění: V rámci ošetření výjimek (ve fázi stack-unwinding) se volají destruktory lokálních proměnných Výjimku zde vyvolanou nelze z technických i logických důvodů ošetřit (ztratila by se původní výjimka) Nastane-li taková výjimka, volá se funkce terminate() a program končí

Pravidla vynucená jazykem Destruktor nesmí skončit vyvoláním výjimky Výjimka může být vyvolána uvnitř, ale musí být zachycena nejpozději uvnitř destruktoru Toto pravidlo jazyka sice platí pouze pro destruktory lokálních proměnných A z jiných důvodů též pro globální proměnné Je však vhodné je dodržovat vždy Bezpečnostní zdůvodnění: Destruktory lokálních proměnných často volají jiné destruktory Logické zdůvodnění: Nesmrtelné objekty nechceme

Pravidla vynucená jazykem Destruktor nesmí skončit vyvoláním výjimky Konstruktor globálního objektu nesmí skončit vyvoláním výjimky Zdůvodnění: Není místo, kde ji zachytit Stane-li se to, volá se terminate() a program končí Jiné konstruktory ale výjimky volat mohou (a bývá to vhodné)

Pravidla vynucená jazykem Destruktor nesmí skončit vyvoláním výjimky Konstruktor globálního objektu nesmí skončit vyvoláním výjimky Copy-constructor typu v hlavičce catch-bloku nesmí skončit vyvoláním výjimky Zdůvodnění: Catch blok by nebylo možné vyvolat Stane-li se to, volá se terminate() a program končí Jiné copy-constructory ale výjimky volat mohou (a bývá to vhodné)

Pravidla vynucená jazykem Destruktor nesmí skončit vyvoláním výjimky Konstruktor globálního objektu nesmí skončit vyvoláním výjimky Copy-constructor typu v hlavičce catch-bloku nesmí skončit vyvoláním výjimky

Poznámka: Výjimky při zpracování výjimky Výjimka při výpočtu výrazu v throw příkaze Tento throw příkaz nebude vyvolán Výjimka v destruktoru při stack-unwinding Povolena, pokud neopustí destruktor Po zachycení a normálním ukončení destruktoru se pokračuje v původní výjimce Výjimka uvnitř catch-bloku Pokud je zachycena uvnitř, ošetření původní výjimky může dále pokračovat (přikazem throw bez výrazu) Pokud není zachycena, namísto původní výjimky se pokračuje ošetřováním nové

Kompilátory samy ošetřují některé výjimky Dynamická alokace polí Dojde-li k výjimce v konstruktoru některého prvku, úspěšně zkonstruované prvky budou destruovány Ve zpracování výjimky se poté pokračuje

Kompilátory samy ošetřují některé výjimky Dynamická alokace polí Dojde-li k výjimce v konstruktoru některého prvku, úspěšně zkonstruované prvky budou destruovány Ve zpracování výjimky se poté pokračuje Výjimka v konstruktoru součásti (prvku nebo předka) třídy Sousední, již zkonstruované součásti, budou destruovány Uvnitř konstruktoru je možno výjimku zachytit speciálním try-blokem: X::X( /* formální parametry */) try : Y( /* parametry pro konstruktor součásti Y */) { /* vlastní tělo konstruktoru */ } catch ( /* parametr catch-bloku */ ) { /* ošetření výjimky v konstruktoru Y i ve vlastním těle */ } Konstrukci objektu nelze dokončit Opuštění speciálního catch bloku znamená throw;

Bezpečné programování s výjimkami

Definice (Weak) exception safety Funkce (operátor, konstruktor) je (slabě) bezpečná, pokud i v případě výjimky zanechá veškerá data v konzistentním stavu Konzistentní stav znamená zejména: Nedostupná data byla korektně destruována a odalokována Ukazatele nemíří na odalokovaná data Platí další invarianty dané logikou aplikace

Definice (Weak) exception safety Funkce (operátor, konstruktor) je (slabě) bezpečná, pokud i v případě výjimky zanechá veškerá data v konzistentním stavu Konzistentní stav znamená zejména: Nedostupná data byla korektně destruována a odalokována Ukazatele nemíří na odalokovaná data Platí další invarianty dané logikou aplikace Strong exception safety Funkce je silně bezpečná, pokud v případě, že skončí vyvoláním výjimky, zanechá data ve stejném (pozorovatelném) stavu, ve kterém byla při jejím vyvolání Observable state - chování veřejných metod Nazýváno též "Commit-or-rollback semantics"

Poznámky (Weak) exception safety Tohoto stupně bezpečnosti lze většinou dosáhnout Stačí vhodně definovat nějaký konzistentní stav, kterého lze vždy dosáhnout, a ošetřit pomocí něj všechny výjimky Konzistentním stavem může být třeba nulovost všech položek Je nutné upravit všechny funkce tak, aby je tento konzistentní stav nepřekvapil (mohou na něj ale reagovat výjimkou) Strong exception safety Silné bezpečnosti nemusí jít vůbec dosáhnout, pokud je rozhraní funkce navrženo špatně Obvykle jsou problémy s funkcemi s dvojím efektem Příklad: funkce pop vracející odebranou hodnotu

Konstruktory a operator=

copy-constructor Silně bezpečné řešení Pokud tělo dorazí na konec, budou datové položky korektně vyplněny Tělo může vyvolávat výjimky V takovém případě není třeba datové položky vyplňovat Objekt nebude považován za platný a nebude používán ani destruován Obecně je však třeba ošetřit try-blokem situace, kdy je v objektu více dynamicky alokovaných ukazatelů Vyplatí se uzavírat ukazatele do tříd po jednom Chytré ukazatele class String { /*...*/ char * str_; }; String( const String & b) { if ( b.str_ ) str_ = new char[ strlen( b.str_) + 1]; strcpy( str_, b.str_); } else throw InvalidString();

copy-constructor Silně bezpečné řešení Chytré ukazatele std::unique_ptr< T> #include <memory> class String { /*...*/ std::unique_ptr< char[]> str_; }; String( const String & b) { if ( b.str_ ) str_.reset( new char[ strlen( b.str_) + 1]); strcpy( str_.get(), b.str_.get()); } else throw InvalidString(); C++11

operator= Silně bezpečné řešení Pokud je copy-constructor silně bezpečný Copy-constructor naplní lokální proměnnou c kopií parametru b Zde může dojít k výjimce Metoda swap_with vyměňuje obsah this a proměnné c Knihovní funkce swap je rychlá a (na ukazatelích) nevyvolává výjimky Před návratem z operatoru se volá destruktor c Tím zaniká původní obsah this #include <algorithm> void String::swap_with( String & x) { swap( str_, x.str_); } String & String::operator=( const String & b) String c( b); swap_with( c); return * this;

operator= Silně bezpečné řešení Metodu swap_with je vhodné publikovat ve formě globální funkce se standardním jménem swap Některé algoritmy nad kontejnery obsahujícími String se tak zrychlí a stanou se bezpečnými vůči výjimkám #include <algorithm> void String::swap_with( String & x) { swap( str_, x.str_); } String & String::operator=( const String & b) String c( b); swap_with( c); return * this; void swap( String & x, String & y) x.swap_with( y); před C++11

Move metody Obvykle negenerují výjimky Některé algoritmy nad kontejnery obsahujícími String se tak zrychlí a stanou se bezpečnými vůči výjimkám Vlastní implementace globální funkce swap není zapotřebí Knihovní implementace swap volá move metody #include <algorithm> String::String( String && b) : str_( std::move( b.str_)) { } String & String::operator=( str_ = std::move( b.str_); return * this; C++11

Funkce s vedlejšími efekty

Příklad: StringStack::pop Zásobník prvků typu String Implementován seznamem Slabě bezpečná implementace: Při výjimce v konstruktoru proměnné s se nestane nic operator delete nezpůsobuje výjimky struct Box { String v; Box * next; }; class StringStack { public: // ... private: Box * top_; }; String StringStack::pop() { if ( ! top_ ) throw StackEmpty(); Box * p = top_; String s = p->v; top_ = p->next; delete p; return s; }

Příklad: StringStack::pop Zásobník prvků typu String Implementován seznamem Slabě bezpečná implementace Není silně bezpečná: Funkce vrací hodnotou Pokud při vracení dojde k výjimce v copy-constructoru, zásobník již bude zkrácen struct Box { String v; Box * next; }; class StringStack { public: // ... private: Box * top_; }; String StringStack::pop() { if ( ! top_ ) throw StackEmpty(); Box * p = top_; String s = p->v; top_ = p->next; delete p; return s; }

Příklad: StringStack::pop Zásobník prvků typu String Implementován seznamem Silně bezpečná implementace Jak zrušíme proměnnou p, když k výjimce nedojde? std::unique_ptr< T> #include <memory> String StringStack::pop() { if ( ! top_ ) throw StackEmpty(); std::unique_ptr< Box> p = top_; top_ = p->next; try { return p->v; } catch ( ...) top_ = std::move( p); // toto přiřazení nuluje p throw; // při návratu se automaticky zruší p // pokud je p nenulové

Příklad: StringStack::pop Zásobník prvků typu String Implementován seznamem Silně bezpečná implementace Uživatel ji nedokáže použít tak, aby to bylo silně bezpečné Vracenou hodnotu je nutné okopírovat Nedá se poznat, zda výjimku vyvolala metoda pop nebo operator= V prvním případě je zásobník nedotčen, ale ve druhém je již zkrácen StringStack stk; String a; /* ... */ try { a = stk.pop(); } catch (...) { /* ??? */

Poučení Funkce, která má vedlejší efekty, smí vracet hodnotou pouze typy, jejichž kopírování nevyvolává výjimky a = stk.pop(); Pokud je třeba nějakou "nebezpečnou" hodnotu vracet, musí se předávat jako výstupní parametr stk.pop( a); Funkcí bez vedlejších efektů se problém netýká a = b + c; StringStack stk; String a; /* ... */ try { a = stk.pop(); } catch (...) { /* ??? */ Většiny operátorů se problém netýká: buď nemají vedlejší efekty, nebo vracejí trvale existující objekt odkazem Problematické jsou postfixové ++, --

Příklad: StringStack::pop Zásobník prvků typu String Implementován seznamem Řešení A Jako v STL Rozdělit pop na dvě funkce top vrací vrchol zásobníku může jej vracet odkazem nemodifikuje data pop pouze zkracuje je silně bezpečná StringStack stk; String a; /* ... */ try { a = stk.top(); } catch (...) { /* chyba kopírování nebo prázdný zásobník, proměnná a nezměněna, zásobník nedotčen */ stk.pop(); /* chyba zkracování, proměnná a změněna,

Příklad: StringStack::pop Zásobník prvků typu String Implementován seznamem Řešení B Namísto vracení hodnoty funkce pop vyplňuje parametr předávaný odkazem tím se vyloučí nutnost kombinovat volání pop s dalším kopírováním Pro uživatele jednodušší, implementace pop je však těžší StringStack stk; String a; /* ... */ try { stk.pop( a); } catch (...) { /* chyba zkracování nebo kopírování, proměnná a nezměněna, zásobník nedotčen */

Příklad: StringStack::pop Zásobník prvků typu String Implementován seznamem Řešení B Lze implementovat nad řešením A #include <memory> class StringStack { public: /* A */ String & top(); void pop(); /* B */ void pop( String & out) { String & t = top(); swap( out, t); try { pop(); } catch (...) { throw; };

Exception specifications

U každé funkce (operátoru, metody) je možno určit seznam výjimek, kterými smí být ukončena Na výjimky ošetřené uvnitř funkce se specifikace nevztahuje Pokud není specifikace uvedena, povoleny jsou všechny výjimky Specifikace respektuje dědičnost, to jest automaticky povoluje i všechny potomky uvedené třídy void a() { /* tahle smí všechno */ } void b() throw () /* tahle nesmí nic */ void c() throw ( std::bad_alloc) /* tahle smí std::bad_alloc */ void d() throw ( std::exception, MyExc) /* tahle smí potomky std::exception a MyExc */ před C++11

Exception specifications U každé funkce (operátoru, metody) je možno určit, že nevyvolává výjimky void a() { /* tahle smí všechno */ } void b() noexcept /* tahle nesmí nic */ C++11

Exception specifications U každé funkce (operátoru, metody) je možno určit, že nevyvolává výjimky noexcept může být podmíněno konstantním booleovským výrazem vhodné pro šablony void a() { /* tahle smí všechno */ } void b() noexcept /* tahle nesmí nic */ template< typename T> void swap( T & a, T & b) noexcept( is_nothrow_move_constructible<T>::value && is_nothrow_move_assignable<T>::value) T c( std::move( a)); a = std::move( b); b = std::move( c); C++11

Koenig lookup

iostream Problém: namespace namespace prostor {
class Souradnice { public: int x, y; }; std::ostream & operator<<( std::ostream & s, const Souradnice & a) { return s << '[' << a.x << ',' << a.y << ']'; } }; prostor::Souradnice p; std::cout << p; // správný operator<< je v namespace prostor, // který není přímo vidět

iostream Problém: namespace namespace prostor {
class Souradnice { public: int x, y; }; std::ostream & operator<<( std::ostream & s, const Souradnice & a) { return s << '[' << a.x << ',' << a.y << ']'; } }; prostor::Souradnice p; std::cout << p; // správný operator<< je v namespace prostor, // který není přímo vidět std::cout << std::endl; // tentýž problém je ale už tady: // tento operator<< je v namespace std

Oba případy jsou překládány správně
Koenig lookup prostor::Souradnice p; std::cout << p; // správný operator<< je v namespace prostor, // který není přímo vidět std::cout << std::endl; // tentýž problém je ale už tady: // tento operator<< je v namespace std Oba případy jsou překládány správně Je k tomu nutná složitá definice vyhledávání identifikátoru tzv. Koenigovo vyhledávání používá se, je-li význam identifikátoru závislý na parametrech volání funkce použití operátoru

Koenigovo vyhledávání (zjednodušeno)
Koenig lookup Koenigovo vyhledávání (zjednodušeno) Argument-dependent name lookup (ISO C++) Pro každý skutečný parametr se z jeho typu T určí množina asociovaných namespace Je-li T číselný, tyto množiny jsou prázdné Je-li T union nebo enum, jeho asociovaným namespace je ten, ve kterém je definován Je-li T ukazatel na U nebo pole U, přejímá asociované namespace od typu U Je-li T funkce nebo ukazatel na funkci, přejímá (sjednocením) asociované namespace všech parametrů a návratového typu Je-li T třída, asociovanými namespace jsou ty, v nichž jsou definovány tato třída a všichni její přímí i nepřímí předkové Je-li T instancí šablony, přejímá kromě asociovaných tříd a namespace definovaných pro třídu také asociované třídy a namespace všech typových argumentů šablony

Koenigovo vyhledávání (zjednodušeno)
Koenig lookup Koenigovo vyhledávání (zjednodušeno) Argument-dependent name lookup (ISO C++) Pro každý skutečný parametr se z jeho typu T určí množina asociovaných namespace Identifikátor funkce se pak vyhledává v těchto prostorech Globální prostor a aktuální namespace Všechny namespace přidané direktivami using Sjednocení asociovaných namespace všech parametrů funkce Všechny varianty funkce nalezené v těchto namespace jsou rovnocenné Mezi nimi se vybírá podle počtu a typu parametrů Pokud není jednoznačně určena nejlepší varianta, je to chyba Volání v kontextu třídy: Je-li identifikátor nalezen uvnitř této třídy nebo některého předka (jako metoda), má přednost před výše uvedenými variantami (globálními funkcemi)

-----------------------------------

Klíčové vlastnosti C++

Zpřístupníme téměř vše, co dokáže „hardware“
Koncepce jazyka C/C++ Zpřístupníme téměř vše, co dokáže „hardware“ Proto máme lokální/globální/dynamicky alokovaná data Ukazatelová aritmetika Nabízíme pouze to, co si programátor neudělá sám Proto nemáme referenční semantiku a garbage collector Nezdržujeme, pokud nemusíme Nevirtuální metody Minimální běhové kontroly Neinicializovaná data Nejsme mateřská školka Konstrukce jsou často nebezpečné

Real programmers can write assembly code in any language.
Koncepce jazyka C/C++ The committee shall make no rule that prevents C++ programmers from shooting themselves in the foot. First Amendment to the C++ Standard (urban legend) In C++ it's harder to shoot yourself in the foot, but when you do, you blow off your whole leg. Bjarne Stroustrup Within C++, there is a much smaller and cleaner language struggling to get out. Real programmers can write assembly code in any language. Larry Wall

Důsledky koncepce C/C++
Existuje mnoho způsobů, jak udělat totéž Špatně čitelné programy Existuje mnoho způsobů, jak udělat chybu Řešení: Dobrovolné omezení síly jazyka Některé možnosti se nevyužívají Chystají se pasti na úmyslná i neúmyslná vybočení Dodržování konvencí a vzorů Využití moudrosti věků Srozumitelnost rozhraní i kódu

Abstraktní pohled na typy

Číselné typy (char, int, double,...) jsou dobře zapouzdřené
Dobře zapouzdřený typ Dobře zapouzdřený typ Nemůže „onemocnět“ při nevhodném používání Zejména z hlediska inicializace, kopírování a úklidu Tím není vyloučena chyba jednotlivých operací dělení nulou, přístup mimo meze pole... Číselné typy (char, int, double,...) jsou dobře zapouzdřené Až na absenci inicializace Ukazatele v C/C++ nejsou dobře zapouzdřené Chybějící inicializací vznikne nedetekovatelný vadný obsah Chybějící úklid může způsobit nedosažitelnost alokované paměti Duplikovaná dealokace je katastrofální chyba Kopírování ukazatelů vede k neřešitelné odpovědnosti za úklid Ukazatele na lokální data mohou ztratit použitelnost ... a mnoho dalších potenciálních problémů

Dobře zapouzdřené typy
Číselné typy (char, int, double,...) jsou dobře zapouzdřené Ukazatele v C/C++ nejsou dobře zapouzdřené Reference v C++ nejsou dobře zapouzdřené Odpadá problém kopírování a dealokace Zůstává problém odkazu na zaniklá data Kontejnery jsou tak dobře zapouzdřené, jako jejich prvky

Dobře zapouzdřené typy
Třída obsahující pouze dobře zapouzdřené prvky Nemusí mít copy-constructor, operator= ani destruktor Sama bude dobře zapouzdřená Konstruktor může být nutný kvůli rozhraní a/nebo logice třídy Třída obsahující prvky, které nejsou dobře zapouzdřené Pokud má být dobře zapouzdřena, musí obsahovat: Konstruktor Copy-constructor operator= Destruktor Prvky musí být privátní

Třídy z pohledu chování
Hodnotové typy Nemají vlastní identitu (3+5 je totéž jako 2+6) Kopírování je bez problémů Jsou to programátorské proměnné, nikoliv matematické hodnoty Dědičnost nemá smysl „Živé“ objekty Mají vlastní identitu (dvě černé vrány nejsou jedna vrána) Mění stav v průběhu života, kopírování nemívá smysl Bývají polymorfní – dědičnost Rozhraní Vnější pohled na plnohodnotný objekt Odkazy Na rozhraní nebo plnohodnotné objekty Nemají vlastní identitu Mohou dovolovat kopírování – musí řešit odpovědnost za úklid Další (funktory, singletony,...)

Třídy z pohledu instanciace
Neinstanciované třídy Policy classes Traits templates Třídy s jednou instancí Singletony Třídy instanciované jako proměnné Hodnotové typy, chytré ukazatele, ... Jednorázové třídy - Funktory, visitory apod. Třídy reprezentující výjimky Třídy instanciované dynamicky Plain Old Data Velká a sdílená data Živé objekty - třídy s hierarchií dědičnosti Poznámka: Toto třídění nemůže být ani úplné ani jednoznačné

Kanonické tvary tříd

Kanonické tvary tříd Singletony

Kanonické tvary tříd Singletony
Veřejná statická funkce zpřístupňující instanci Lokální statická proměnná obsahuje jedinou instanci Privátní konstruktor a destruktor Znemožní vytváření a likvidaci mimo předepsaná místa Privátní hlavička copy-constructoru a operatoru= Tělo se neimplementuje Znemožní kopírování Většinou nevyužívají dědičnost ani virtuální funkce /* syslog.h */ class SysLog { public: static SysLog & instance() { static SysLog inst; return inst; } void write( const std::string & s) { os_ << s; } private: std::ofstream os_; SysLog() : os_("syslog") {} ~SysLog() {} SysLog( const SysLog &); void operator=( const SysLog &); }; /* pouziti */ Syslog::instance().write( "Hi");

Kanonické tvary tříd Hodnotové typy

Kanonické tvary tříd Hodnotové typy – jednoduché případy
Obsahují pouze dobře zapouzdřené prvky Číselné typy Jiné dobře zapouzdřené třídy Prvky mohou být veřejné Pokud nemusí dodržovat nějaký invariant class Complex { public: double re, im; Complex(); Complex( double r, double i = 0); Complex operator-() const; Complex & operator+=( const Complex &); }; Complex operator+( const Complex &, const Complex &);

Obsahují pouze dobře zapouzdřené prvky Číselné typy Jiné dobře zapouzdřené třídy Privátní prvky mívají zpřístupňující metody set/get konvence class Complex { public: Complex(); Complex( double r, double i = 0); double get_re() const; void set_re( double x); double get_im() const; void set_im( double x); Complex operator-() const; Complex & operator+=( const Complex &); private: double re_, im_; }; Complex operator+( const Complex &, const Complex &);

Obsahují pouze dobře zapouzdřené prvky Privátní prvky mívají zpřístupňující metody Konstruktory s parametry (někdy) Konverze, inicializace Mohou nahradit set-metody Konstruktor bez parametrů Pokud jsou konstruktory s parametry Pokud třída obsahuje atomické číselné typy class Complex { public: Complex(); Complex( double r, double i = 0); double get_re() const; void set_re( double x); double get_im() const; void set_im( double x); Complex operator-() const; Complex & operator+=( const Complex &); private: double re_, im_; }; Complex operator+( const Complex &, const Complex &);

Obsahují pouze dobře zapouzdřené prvky Konstruktory s parametry (někdy) Konstruktor bez parametrů Copy-constructor, operator=, destruktor nejsou zapotřebí Vyhovuje chování generované překladačem class Complex { public: Complex(); Complex( double r, double i = 0); double get_re() const; void set_re( double x); double get_im() const; void set_im( double x); Complex operator-() const; Complex & operator+=( const Complex &); private: double re_, im_; }; Complex operator+( const Complex &, const Complex &);

Kanonické tvary tříd Hodnotové typy
Unární a modifikující binární operátory jako metody unární operátory (včetně postfixového ++) vrací hodnotou modifikující operátory (vyjma postfixového ++) vrací odkazem * this Nemodifikující binární operátory jako globální funkce Vrací hodnotou Většinou lze implementovat pomocí modifikujících binárních operátorů class Complex { public: double re, im; Complex(); Complex operator-() const; Complex & operator+=( const Complex &); }; Complex operator+( const Complex & a, const Complex & b) { Complex tmp( a); tmp += b; return tmp; }

Kanonické tvary tříd Hodnotové typy Dědičnost nemá smysl
Virtuální funkce nemají smysl class Complex { public: double re, im; Complex(); Complex operator-() const; Complex & operator+=( const Complex &); }; Complex operator+( const Complex & a, const Complex & b) { Complex tmp( a); tmp += b; return tmp; }

Kanonické tvary tříd Hodnotové typy - složitější případy
Obsahují nedostatečně zapouzdřené prvky Ukazatele apod. Konstruktor bez parametrů Copy-constructor operator= Destruktor Data a pomocné funkce privátní class Matrix { public: Matrix(); Matrix( const Matrix &); Matrix & operator=( const Matrix &); ~Matrix(); Matrix operator-() const; Matrix & operator+=( const Matrix &); friend Matrix operator+( const Matrix &, const Matrix &); private: int m_, n_; double * d_; }; Matrix operator+(

Kanonické tvary tříd Hodnotové typy - složitější případy
Obsahují nedostatečně zapouzdřené prvky Ukazatele apod. Více než jeden dynamicky alokovaný blok Problémy s exception-safety Vyplatí se samostatně zapouzdřit ukazatele do pomocných tříd class Matrix { public: Matrix(); Matrix( const Matrix &); Matrix & operator=( const Matrix &); ~Matrix(); Matrix operator-() const; Matrix & operator+=( const Matrix &); friend Matrix operator+( const Matrix &, const Matrix &); private: int m_, n_; double * d_; }; Matrix operator+(

Kanonické tvary tříd Funktory, visitory

Kanonické tvary tříd Třídy instanciované jako proměnné Funktory
Třídy určené k předávání šablonovaným funkcím Obvykle používány pouze jednou Co nejjednodušší konstrukce Konstruktor S požadovanými parametry Data Metoda implementující požadovanou operaci Typicky operator() Dědičnost nemá smysl struct Printer { public: Printer( std::ostream & o) : out_( o) {} void operator()( int x) { o << x << std::endl; } private: std::ostream & out_; }; std::vector< int> v; for_each( v.begin(), v.end(), Printer( std::cout));

Kanonické tvary tříd Třídy instanciované jako proměnné
Abstraktní visitor Sada čistě virtuálních funkcí Virtuální destruktor Prázdné tělo Vše veřejné Konkrétní visitor Obvykle používán pouze jednou Co nejjednodušší konstrukce Kontrola přístupu není nutná Potomek abstraktní třídy Privátní nebo veřejná data Konstruktor (jsou-li data) Virtuální metody implementující požadované operace class Visitor { public: virtual void visitEllipse( Ellipse *)=0; virtual void visitRectangle( Rectangle *)=0; virtual void visitLine( Line *)=0; virtual ~Visitor() {} }; class PrintVisitor : public Visitor { PrintVisitor( Printer * p) : p_( p) {} virtual void visitEllipse( Ellipse *); virtual void visitRectangle( Rectangle *); virtual void visitLine( Line *); private: Printer * p_;

Dynamicky alokovaná data
Kanonické tvary tříd Dynamicky alokovaná data

Kanonické tvary tříd Třídy instanciované dynamicky Plain Old Data
Neobsahují dynamicky alokované součásti Datové položky obvykle veřejné Většinou bez konstruktoru Nedefinuje se copy-constructor, operator= ani destruktor Bez virtuálních funkcí a dědičnosti Někdy s obyčejnými metodami class Configuration { public: bool show_toolbar; bool show_status_bar; int max_windows; }; Dynamická alokace pouze kvůli požadované životnosti Pro srovnání Pojem "Plain Old Data" (POD) je definován jazykem C++ takto: Třída nemá žádný konstruktor ani destruktor Třída nemá virtuální funkce ani virtuální dědičnost Všichni předkové a datové položky jsou POD POD-třída má zjednodušená pravidla: Může být součástí unie Může být staticky inicializována

Kanonické tvary tříd Třídy instanciované dynamicky
Velká a sdílená data Často obsahuje definice typů Konstruktor nebo několik konstruktorů, často s parametry Destruktor Privátní datové položky Manipulace prostřednictvím metod udržujících konzistenci Obvykle privátní neimplementovaný copy-constructor a operator= Většinou bez virtuálních funkcí a dědičnosti Dynamická alokace kvůli velikosti a životnosti class ColoredGraph { public: typedef int node_id; typedef int edge_id; typedef int color; ColoredGraph(); ColoredGraph( istream &); ~ColoredGraph(); node_id add_node(); edge_id add_edge( node_id, node_id, color); /* ... */ private: vector< node_id> nodes_; multimap< node_id, edge_id> edges_; map< edge_id, color> colors_; ColoredGraph(const ColoredGraph &); void operator=(const ColoredGraph &); };

Prvky datových struktur Obsahují ukazatele Konstruktor (inicializace ukazatelů) Další konstruktory, jsou-li využitelné Destruktor jen tehdy, pokud může mít dobře definované chování Datové položky někdy veřejné Nepolymorfní struktury: bez virtuálních funkcí a dědičnosti Konzistentní manipulace zajištěna zapouzdřením celé struktury do jiné třídy Dynamická alokace kvůli životnosti a složitosti struktury class TreeNode { public: TreeNode() : left( 0), right( 0) {} TreeNode( TreeNode * l, TreeNode * r) : left( l), right( r) {} ~TreeNode() { /* ??? */ } TreeNode * left, * right; }; class Tree { Tree() : root( 0) {} ~Tree() { /* ... */ } void insert_node( /* ??? */ ); private: TreeNode * root;

Prvky datových struktur Datové položky někdy veřejné Konzistentní manipulace zajištěna zapouzdřením celé struktury do jiné třídy Problém: zpřístupnění prvků vnějšímu světu class Tree { public: Tree() : root( 0) {} ~Tree() { /* ... */ } void insert_node( /* ??? */ ); /* ??? */ find_node( /* ... */ ); private: class TreeNode { TreeNode() : left( 0), right( 0) {} ~TreeNode() { /* ??? */ } TreeNode * left, * right; }; TreeNode * root;

Prvky datových struktur Datové položky někdy veřejné Konzistentní manipulace zajištěna zapouzdřením celé struktury do jiné třídy Problém: zpřístupnění prvků vnějšímu světu Lze řešit zapouzdřením ukazatelů do tříd – viz iterátory Shrnuto: NodeRef - technicky hodnotová třída s přiznanou referenční semantikou Tree – obvykle nekopírovatelná třída TreeNode - PlainOldData class Tree { private: class TreeNode { public: /* ... */ TreeNode * left, * right; }; class NodeRef { TreeNode * p; Tree() : root( 0) {} ~Tree() { /* ... */ } NodeRef create_node( /* ... */); void insert_node( NodeRef p); NodeRef find_node( /* ... */ ); TreeNode * root; Tree( const Tree &); /* ... */

Kanonické tvary tříd Třídy s dědičností

Třídy s hierarchií dědičnosti "Objektové programování" Abstraktní třída Sada veřejných (čistě) virtuálních funkcí Veřejný virtuální destruktor Prázdné tělo Konstruktor obvykle protected Chrání proti instanciaci, pokud nejsou čistě virtuální funkce Pro jistotu: privátní neimplementovaný copy-constructor a operator= Kopírování metodou clone Žádné datové položky class AbstractObject { public: virtual void doit() {} virtual void showit( Where *) const = 0; virtual AbstractObject * clone() const = 0; virtual ~AbstractObject() {} protected: AbstractObject() {} private: AbstractObject( const AbstractObject&); void operator=( };

Třídy s hierarchií dědičnosti "Objektové programování" Konkrétní třída Potomek abstraktní třídy Veřejný konstruktor Virtuální funkce obvykle protected Privátní data class ConcreteObject : public AbstractObject { public: ConcreteObject( /*...*/); protected: virtual void doit(); virtual void showit( Where *) const; virtual AbstractObject * clone() const; virtual ~ConcreteObject(); private: /* data */; };

Neinstanciované třídy
Kanonické tvary tříd Neinstanciované třídy

Kanonické tvary tříd Neinstanciované třídy Policy classes
Traits templates Obsahují pouze Definice typů (typedef, případně vnořené třídy) Definice výčtových konstant (a typů) Statické funkce Statická data Obvykle vše veřejné (struct) Nemají konstruktory ani destruktory Obvykle nevyužívají dědičnost struct allocation_policy { static void * alloc( size_t); static void free( void *); }; template< typename T> struct type_traits; template<> struct type_traits< char> { typedef char param_type; enum { min = 0, max = 255 }; static bool less( char, char);

Kanonické tvary tříd Policy class – použití Univerzální šablona
template< class policy> class BigTree { /* ... */ Node * new_node() { return policy::alloc(sizeof(Node)); } }; Specifická policy class struct my_policy { static void * alloc( size_t); static void free( void *); Použití BigTree< my_policy> my_tree; Traits template – použití Deklarace traits template< class T> struct type_traits; Univerzální šablona template< class T> class Stack { /* ... */ void push( typename type_traits::param_t x); }; Univerzální definice traits struct type_traits { typedef const T & param_t; Explicitní specializace traits template<> struct type_traits< char> { typedef char param_t;

Traits a kontejnery template< typename K>
struct for_each_traits; void for_each( K & data) { typedef typename K::value_type T; for( ... it = ... ) for_each_traits< T>::f( it); } template< typename U> class vector { public: typedef U value_type; ... }; template<> struct for_each_traits< int> { static void f(...) { } typedef vector< int> my_k; my_k data; for_each( data);

Traits a iterátory template< typename K> struct for_each_traits;
template< typename IT> void for_each( IT b, IT e) { typedef typename iterator_traits< IT>::value_type T; for( ... it = ... ) for_each_traits< T>::f( it); } template<> struct for_each_traits< int> { static void f(...) { ... } }; typedef int my_k[ N]; my_k data; for_each( data, data + N); // IT = int*

Lambda (C++0x) template< typename P> void modify( const P & x) {
for( ... it = ... ) * it = x.operator()( * it); } struct functor_twice { int operator()( int x) const return 2 * x; }; modify( functor_twice()); for_each( []( int x){ return 2 * x });

Lambda (C++0x vs. boost) for_each( []( int x){ return 2 * x });
for_each( constant( 2) * _1);

Lambda (boost) struct functor_1 { template< typename T>
T operator()( T x) const { return x; } }; extern functor_1 _1; struct functor_const { functor_const( T c) : c_( c) {} return c_; T c_; functor_const< T> constant( T c) { return functor_const< T>( c); } template< typename F1, typename F2> struct functor_mul { functor_mul( F1 f1, F2 f2) : f1_( f1), f2_( f2) {} T operator()( T x) const { return c_; } F1 f1_; F2 f2_; }; functor_mul< F1, F2> operator+ ( F1 f1, F1 f2) return functor_const< F1, F2> ( f1, f2); for_each( constant( 2) * _1);

Lambda (boost) - problémy
for_each( std::cout << "x=" << _1); for_each( constant( 2) * _1);

Šablony Templates

Šablony tříd - instanciace
Instanciace šablony: Šablonu lze použít jako typ pouze s explicitním uvedením skutečných parametrů odpovídajících druhů: celé číslo: celočíselný konstantní výraz ukazatel: adresa globální nebo statické proměnné či funkce kompatibilního typu libovolný typ – jméno typu či typová konstrukce (včetně jiné instanciované šablony) Užití instanciované šablony: Instanciované šablony jsou stejného typu, pokud jsou stejného jména a jejich skutečné parametry obsahují stejné hodnoty konstantních výrazů, adresy stejných proměnných či funkcí a stejné typy

Šablony tříd – pravidla použití
Uvnitř těla šablony (nebo jako její předky) je možno užívat libovolné typy včetně: Instancí jiných šablon Téže šablony s jinými argumenty Téže šablony se stejnými argumenty V tomto případě se argumenty mohou, ale nemusí opisovat Ekvivalentní varianty šablony s copy-constructorem: template< typename T> class X { X( const X< T> &); }; X( const X &); Některé překladače připouštějí i tuto variantu X< T>( const X< T> &);

Metody šablon mohou mít těla uvnitř třídy nebo vně Vně uvedená těla metod musejí být připojena k šabloně takto: template< typename T> void X< T>::f( int a, int b) { /* ... */ } V kvalifikovaném jméně metody je nutné uvést patřičný seznam argumentů, tj. X< T>::f a nikoliv X::f Těla metod musejí být viditelná z každého místa, kde jsou pro nějakou instanci šablony volána Musejí tedy typicky být v témže hlavičkovém souboru jako sama šablona. Uvedení těla metody vně třídy tedy u šablon typicky nic nepřináší, může být však vynuceno rekurzivními odkazy mezi šablonami apod.

Šablona třídy se překládá až v okamžiku instanciace, tj. použití s konkrétními parametry Překladač instanciuje (tj. překládá) pouze ty metody, které jsou zapotřebí (tj. jsou volány nebo jsou virtuální) Některá těla metod tedy nemusí být pro některé případy parametrů přeložitelná template< typename Container> class Proxy { public: void pop_front() { c->pop_front(); } // jen pro list/deque /* ... */ private: Container * c; }; Explicitní instanciace Překladač je možné donutit ke kompletní instanciaci šablony template class Array< 128, char>;

Dopředná deklarace šablony
Šablony tříd – triky Dopředná deklarace šablony template< typename T> class X; /* ... zde může být použito X s jakýmikoliv argumenty U... ... pouze v kontextech, kde kompilátor nepotřebuje znát tělo šablony ... */ template< typename T> class X { /* ... */ };

Šablony funkcí Pod stejným identifikátorem může být deklarováno několik různých šablon funkce a navíc několik obyčejných funkcí. Obyčejné funkce mají přednost před generickými template< class T> T max( T a, T b) { return a T max( Array< n, T> a) { /* ... */ } Příklad ze standardních knihoven: template< class T> void swap( T & a, T & b) { T tmp(a); a = b; b = tmp; }; K tomu řada chytřejších implementací swap pro některé třídy

Šablony – pokročilé konstrukce jazyka
Parciální specializace Deklarovanou šablonu lze pro určité kombinace parametrů předefinovat jinak, než určuje její základní definice template< int n> class Array< n, bool> { /* specializace pro pole typu bool */ }; Krajním případem parciální specializace je explicitní specializace Explicitní specializace template<> class Array< 32, bool> { /* ... */ }; U šablon funkcí nahrazena obyčejnou funkcí Explicitní instanciace Překladač je možné donutit ke kompletní instanciaci šablony template class Array< 128, char>;

Deklarovanou šablonu lze pro určité kombinace parametrů předefinovat jinak, než určuje její základní definice Parciálně specializovat lze šablony funkcí, celé šablony tříd i jednotlivě těla jejich metod Obsah specializace šablony třídy (teoreticky) nemusí nijak souviset se základní definicí - může mít zcela jiné položky, předky apod. Základní definice dokonce nemusí vůbec existovat (ale musí být deklarována) template< class X, class Y> class C; // základní deklarace template< class P, class Q> class C { // specializace bool cmp( P *, Q *); }; template< class Z> class C< Z, Z> : public Z { // jiná specializace bool set( Z &); template< class X, class Y> class C { // základní definice X add( Y);

Deklarovanou šablonu lze pro určité kombinace parametrů předefinovat jinak, než určuje její základní definice Parciální specializace může mít stejný, menší i větší počet formálních parametrů než základní definice, jejich hodnoty se odvozují ze skutečných parametrů šablony (kterých je vždy tolik, kolik určuje základní definice) template< class T, class U, int n> class C< T[n], U[n]> { /* specializace pro dvě pole stejné velikosti */ };

Příklad template< int N> struct Fact { enum { value = Fact< N-1>::value * N }; }; template<> struct Fact< 0> { enum { value = 1 };

Příklad template< int N> struct Fact { enum { value = Fact< N-1>::value * N }; }; template<> struct Fact< 0> { enum { value = 1 }; Použití enum { N = 10 }; int permutations[ Fact< N>::value];

Příklad template< int N> struct Fact { enum { value = Fact< N-1>::value * N }; }; template<> struct Fact< 0> { enum { value = 1 }; Kontrolní otázka: Kolik je Fact< -1>::value

Příklad template< int N> struct Fact { enum { value = Fact< N-1>::value * N }; }; template<> struct Fact< 0> { enum { value = 1 }; Kontrolní otázka: Kolik je Fact< -1>::value MS Visual C++ 7.1: fatal error C1202: recursive type or function dependency context too complex Řetěz instanciací Fact< -1>, Fact< -2>, Fact< -3>, ... způsobí přetečení tabulek kompilátoru

Šablony tříd – explicitní instanciace
Je-li předem známa množina typů (formálních parametrů), pro něž se bude šablona instanciovat, není nutno publikovat těla metod ve zdrojové formě a je možné je předkompilovat do knihovny Veřejný hlavičkový soubor X.h – hlavička třídy template< class T> class X { /* ... */ void f(/*...*/); }; Nepublikovaný hlavičkový soubor XBody.h Generická těla metod #include "X.h" template< class T> void X< T>::f(/*...*/) { /*...*/ } Knihovní modul XBodyInt.cpp Instanciace pro typ int #include "XBody.h" template X< int>;

Šablona třídy je kompilátorem vyhodnocovaná funkce f : Ti  T T je množina všech typů zkonstruovatelných v jazyce C

Šablona třídy je kompilátorem vyhodnocovaná funkce f : Ti  T T je množina všech typů zkonstruovatelných v jazyce C f : Ti × Kj  T šablona s celočíselnými parametry K je množina všech celočíselných konstant

Šablona třídy je kompilátorem vyhodnocovaná funkce f : Ti  T T je množina všech typů zkonstruovatelných v jazyce C f : Ti × Kj  T šablona s celočíselnými parametry K je množina všech celočíselných konstant f : Ti × Kj  Tm × Kn výsledná třída může obsahovat typy a konstanty

Šablona třídy je kompilátorem vyhodnocovaná funkce f : Ti × Kj  Tm × Kn Taková funkce může být definována Jedním předpisem Základní šablonou Po částech Parciálními specializacemi šablony V jednotlivých bodech Explicitními specializacemi šablony

Exception handling Mechanismus výjimek

Používat throw a catch je jednoduché Těžší je programovat běžný kód tak, aby se choval korektně i za přítomnosti výjimek Exception-safety Exception-safe programming void f() { int * a = new int[ 100]; int * b = new int[ 200]; g( a, b); delete[] b; delete[] a; } Pokud new int[ 200] způsobí výjimku, procedura zanechá naalokovaný nedostupný blok Pokud výjimku vyvolá procedura g, zůstanou dva nedostupné bloky