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++.

1. C++11
Un aperçu en 12 exemples

2. En bref
• Syntaxe pratique
• Plus clair et plus sûr
• Nouvelles fonctionnalités
• Stl améliorée
2

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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. Nouvelles fonctionnalités : et aussi …
18
• Constant expressions
• Variadic templates
• Assertions statiques

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. 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. 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. Std améliorée : et aussi …
22
• Performances améliorées
• Chrono
• Nouveaux conteneurs, nouveaux algorithmes
• Tuples

23. 23
A vos questions