C++11 
Un aperçu en 12 exemples
En bref 
• Syntaxe pratique 
• Plus clair et plus sûr 
• Nouvelles fonctionnalités 
• Stl améliorée 
2
Syntaxe pratique #1 : auto 
auto i = 42; // i is an int 
auto p = new Foo(42); // p is a Foo* 
3 
C++11
Syntaxe pratique #1 : auto 
4 
for(vector<int>::const_iterator it = v.begin(); it != v.end(); ++it) 
{ 
… 
} 
for(auto it ...
Syntaxe pratique #2 : listes d’initialisateurs 
5 
std::vector<int> nombres; 
nombres.push_back(1); 
nombres.push_back(2);...
Syntaxe pratique #3 : foreach 
6 
vector<int> nombres; 
for(int i = 0 ; i < nombres.size() ; i++) 
{ 
vector<int> nombres;...
Plus clair et plus sûr #1 : héritage virtuel 
7 
class A 
{ 
virtual void f() const; 
}; 
class B : public A 
{ 
void f();...
Plus clair et plus sûr #1 : héritage virtuel 
8 
class A 
{ 
virtual void f() const; 
}; 
class B : public A 
{ 
virtual v...
Plus clair et plus sûr #1 : héritage virtuel 
9 
class A 
{ 
virtual void f() final; 
}; 
class B : public A 
{ 
virtual v...
Plus clair et plus sûr #2 : enums 
10 
enum Selection 
{ 
None, 
Single, 
Multiple 
}; 
enum Border 
{ 
None, 
Flat, 
Rais...
Plus clair et plus sûr #2 : enums 
11 
enum class Selection 
{ 
None, 
Single, 
Multiple 
}; 
enum class Border 
{ 
None, ...
Plus clair et plus sûr #3 : nullptr 
12 
int* p1 = NULL; // macro 
int* p2(0); 
void f(int n); 
void f (char *s); 
f( NULL...
Nouvelle fonctionnalité #1 : lambdas 
13 
void f(std::vector<int>& v) 
{ 
struct DoSomething 
{ 
void operator()(int) 
{ 
...
Nouvelle fonctionnalité #1 : lambdas 
14 
void f(std::vector<int>& v) 
{ 
void f (std::vector<int>& v) 
{ 
C++03 
std::for...
Nouvelle fonctionnalité #2 : move and rvalues 
15 
template <class T> swap(T& a, T& b) 
{ 
template <class T> swap(T& a, T...
Nv. fonctionnalité #3 : delegated constructor 
16 
class Unloader 
{ 
public: 
Unloader(std::string name, int arms_number)...
Nv. fonctionnalité #3 : delegated constructor 
17 
class Unloader 
{ 
public: 
Unloader(std::string name, int arms_number)...
Nouvelles fonctionnalités : et aussi … 
18 
• Constant expressions 
• Variadic templates 
• Assertions statiques
Std améliorée #1 : smart pointers 
19 
shared_ptr<Foo> sptr1( new Foo ); 
shared_ptr<Foo> sptr2 = sptr1; // reference coun...
Std améliorée #2 : regex 
20 
std::string names[] = {"foo.txt", "foo.bat"}; 
std::regex txt_regex("[a-z]+.txt"); 
C++11 
f...
Std améliorée #3 : threading 
21 
void call_from_thread() 
{ 
std::cout << "Hello world" << std::endl; 
} 
int main() 
{ 
...
Std améliorée : et aussi … 
22 
• Performances améliorées 
• Chrono 
• Nouveaux conteneurs, nouveaux algorithmes 
• Tuples
23 
A vos questions
Prochain SlideShare
Chargement dans…5
×

C++11 en 12 exemples simples

183 vues

Publié le

C++11 en 12 exemples simples, un aperçu des nouvelles fonctionnalités du langage.

C++11 by 12 simple examples, a glance at the new features of C++.

Publié dans : Logiciels
0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
183
Sur SlideShare
0
Issues des intégrations
0
Intégrations
4
Actions
Partages
0
Téléchargements
5
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive
  • Avant: boost assign
    Fonctionne aussi avec maps
  • Namespacing lourd
  • + cast en int pas automatique
  • désormais type std::nullptr_t
  • Fonctions anonymes, passables en paramètre ou stockables en variables
  • (+) élements non copiables mais déplaçables (e.g. stream, unique_pointer)
  • A la boost : shared/weak (éviter références cycliques, mise e nbcache) / unique (seulement un possesseur)
  • C++11 en 12 exemples simples

    1. 1. C++11 Un aperçu en 12 exemples
    2. 2. En bref • Syntaxe pratique • Plus clair et plus sûr • Nouvelles fonctionnalités • Stl améliorée 2
    3. 3. Syntaxe pratique #1 : auto auto i = 42; // i is an int auto p = new Foo(42); // p is a Foo* 3 C++11
    4. 4. Syntaxe pratique #1 : auto 4 for(vector<int>::const_iterator it = v.begin(); it != v.end(); ++it) { … } for(auto it = v.begin(); it != v.end(); ++it) { … } C++03 C++11
    5. 5. Syntaxe pratique #2 : listes d’initialisateurs 5 std::vector<int> nombres; nombres.push_back(1); nombres.push_back(2); nombres.push_back(3); nombres.push_back(4); nombres.push_back(5); C++03 std::vector<int> nombres = { 1, 2, 3, 4, 5 }; C++11
    6. 6. Syntaxe pratique #3 : foreach 6 vector<int> nombres; for(int i = 0 ; i < nombres.size() ; i++) { vector<int> nombres; for(int &element : nombres) { cout << element << endl; } int & element = nombres[i] ; cout << element << endl; } C++03 C++11
    7. 7. Plus clair et plus sûr #1 : héritage virtuel 7 class A { virtual void f() const; }; class B : public A { void f(); // intentionally not overriding? }; C++03
    8. 8. Plus clair et plus sûr #1 : héritage virtuel 8 class A { virtual void f() const; }; class B : public A { virtual void f() override; // error, f does not override }; C++11
    9. 9. Plus clair et plus sûr #1 : héritage virtuel 9 class A { virtual void f() final; }; class B : public A { virtual void f(); // error, f is final }; C++11
    10. 10. Plus clair et plus sûr #2 : enums 10 enum Selection { None, Single, Multiple }; enum Border { None, Flat, Raised }; Selection sel = None; // name clash C++03
    11. 11. Plus clair et plus sûr #2 : enums 11 enum class Selection { None, Single, Multiple }; enum class Border { None, Flat, Raised }; Selection sel = Selection::None; C++11
    12. 12. Plus clair et plus sûr #3 : nullptr 12 int* p1 = NULL; // macro int* p2(0); void f(int n); void f (char *s); f( NULL ); // which function is called? int* p2 = nullptr; int i = nullptr; // error C++03 C++11
    13. 13. Nouvelle fonctionnalité #1 : lambdas 13 void f(std::vector<int>& v) { struct DoSomething { void operator()(int) { // do something } }; DoSomething do_something; std::for_each(v.begin(), v.end(), do_something); } C++03
    14. 14. Nouvelle fonctionnalité #1 : lambdas 14 void f(std::vector<int>& v) { void f (std::vector<int>& v) { C++03 std::for_each(v.begin(), v.end(), [](int) { /* do something here*/ }); } struct DoSomething { void operator()(int) { // do something } }; DoSomething do_something; std::for_each(v.begin(), v.end(), do_something); } C++11
    15. 15. Nouvelle fonctionnalité #2 : move and rvalues 15 template <class T> swap(T& a, T& b) { template <class T> swap(T& a, T& b) { T tmp(std::move(a)); a = std::move(b); b = std::move(tmp); } T tmp(a); a = b; b = tmp; } C++03 C++11
    16. 16. Nv. fonctionnalité #3 : delegated constructor 16 class Unloader { public: Unloader(std::string name, int arms_number) : m_name(name), m_arms_number(arms_number) { } Unloader() : m_name(""), m_arms_number(0) // duplicated code { } protected: const std::string m_name; const int m_arms_number; }; C++03
    17. 17. Nv. fonctionnalité #3 : delegated constructor 17 class Unloader { public: Unloader(std::string name, int arms_number) : m_name(name), m_arms_number(arms_number) { } Unloader() : Unloader("", 0) { } protected: const std::string m_name; const int m_arms_number; }; C++11
    18. 18. Nouvelles fonctionnalités : et aussi … 18 • Constant expressions • Variadic templates • Assertions statiques
    19. 19. Std améliorée #1 : smart pointers 19 shared_ptr<Foo> sptr1( new Foo ); shared_ptr<Foo> sptr2 = sptr1; // reference counter incremented std::unique_ptr<Foo> uptr1(new Foo); std::unique_ptr<Foo> uptr2(std::move(uptr1)); // p2 owns Foo std::weak_ptr<Foo> wptr1 = sptr1; // wptr1.lock() == sptr1 sptr1.reset( new Foo ); // wptr1.expired() == true C++11
    20. 20. Std améliorée #2 : regex 20 std::string names[] = {"foo.txt", "foo.bat"}; std::regex txt_regex("[a-z]+.txt"); C++11 for (const auto &n: names) { std::cout << n<< ": " << std::regex_match(fname, txt_regex) << " / "; } // Prints foo.txt: 1 / foo.bat: 0
    21. 21. Std améliorée #3 : threading 21 void call_from_thread() { std::cout << "Hello world" << std::endl; } int main() { std::thread t1(call_from_thread); // thread launch t1.join(); // join thread with main thread return 0; } C++11
    22. 22. Std améliorée : et aussi … 22 • Performances améliorées • Chrono • Nouveaux conteneurs, nouveaux algorithmes • Tuples
    23. 23. 23 A vos questions

    ×