C++11 (formerly known as C++0x) is the new C++ language standard. Dave Abrahams, BoostPro Computing

C++ 2011
Highlights from the New International Standard

1
Monday, September 19, 2011

Intro

• Who am I

• Who are you?

• Why We’re Here

2

C++11 Goals
• Make C++ a better language for systems
programming

• Make C++ a better language for writing libraries

• Make C++ more teachable and learnable

• Maintain backward compatibility

3

C++11 At a Glance
• General Core Language Features
concurrency, move semantics, auto, range-based for, lambdas…

• Library Features
containers, regular expressions, smart pointers, new algorithms…

• Features for writing classes
constructor delegation, override/final, =default/=delete…

• Crazy Template Stuff
Variadic templates, template aliases, decltype, perfect forwarding, …

4

Ponies for Everybody!
Big wins from little features

5

Type Deduction

void print_3x(vector<float> const& v)
{
for ( vector<float>::const_iterator p = v.begin();
p != v.end(); p++ )
{
std::cout << *p * 3 << " ";
}
}

6

Type Deduction

{
for ( auto p = v.begin();
p != v.end(); p++ )
{
std::cout << *p * 3 << " ";
}
}

7

Type Deduction

{
for ( auto p = v.begin(); p != v.end(); p++ )
{
std::cout << *p * 3 << " ";
}
}

8

Type Deduction
auto a = 3; int
const auto b = 3.14; const double
auto const& c = 42; int const&

auto d = "foobar"; char const*
auto& e = "baz" char const(&)[4]

extern std::list<Foo> l;
auto p = l.begin(); std::list<Foo>::iterator
auto& x = l.front(); std::list<Foo>::value_type&

auto& y = any-expression-here;

9

Type Deduction

{
{
std::cout << *p * 3 << " ";
}
}

10

Range-based for loop

{
{
std::cout << *p * 3 << " ";
}
}

11


{
for ( float a: v )
{
std::cout << a * 3 << " ";
}
}

12


Range
{
for ( float a: v )
{
std::cout << a * 3 << " ";
}
}

12


Loop variable Range
{
for ( float a: v )
{
std::cout << a * 3 << " ";
}
}

12

auto in C++11

{
for ( auto a: v )
{
std::cout << a * 3 << " ";
}
}

13


template <class Range>
void print_3x(Range const& v)
{
for ( typename Range::value_type a: v )
{
std::cout << a * 3 << " ";
}
}

14

auto in C++11

template <class Range>
void print_3x(Range const& v)
{
for ( auto a: v )
{
std::cout << a * 3 << " ";
}
}

15

auto in C++11

void inplace_3x(vector<float>& v)
{
for ( float& a: v )
{
a *= 3;
}
}

16

Ranges Everywhere
int rng[3] = { 42, 314, 77 };
for( int var: rng )
{
...
}

17

Ranges Everywhere
std::pair<Iter,Iter> rng = … ;
for( int var: rng )
{
...
}

18

Ranges Everywhere
YourType rng;
for( int var: rng )
{
...
}

19

98
++Range-based for loop
C

{
BOOST_FOREACH( float a, v )
{
std::cout << a * 3 << " ";
}
}

20

98
++Range-based“for”loop
C

{
{
std::cout << a * 3 << " ";
}
}

20

98
++Range-based“for”loop
C

{
{
std::cout << a * 3 << " ";
}
}

See your friendly neighborhood
Boost C++ Libraries for details

20

Using an Algorithm

{
std::for_each(
v.begin(), v.end(), );
}

21

Using an Algorithm
static void print_3x_element(float a)
{
std::cout << a * 3 << " ";
}

{
std::for_each(
v.begin(), v.end(), );
}

21

Using an Algorithm
static void print_3x_element(float a)
{
std::cout << a * 3 << " ";
}

{
std::for_each(
v.begin(), v.end(), print_3x_element);
}

21

Lambda Expressions

{
std::for_each(
v.begin(), v.end(),
);
}

22

Lambda Expressions

{
std::for_each(
v.begin(), v.end(),
[](float a) { std::cout << a * 3 << " "; } );
}

“Lambda expression”

22

Lambda Expressions

{
std::for_each(
v.begin(), v.end(),
[](float a) { std::cout << a * 3 << " "; } );
}

23

Lambda Expressions

{
std::for_each(
v.begin(), v.end(),
[](float a) { std::cout << a * 3 << " "; } );
}

introducer

23

What It Is

{
std::for_each(
v.begin(), v.end(),
[](float a) { std::cout << a * 3 << " "; } );
}

24

anonymous class
What It Is
struct __lambda143
{
inline void operator()(float a) const
{ std::cout << a * 3 << " "; }
};

{
std::for_each(
v.begin(), v.end(),
[](float a) { std::cout << a * 3 << " "; } );
}

24

anonymous class
What It Is
struct __lambda143
{
inline void operator()(float a) const
{ std::cout << a * 3 << " "; }
};

{
std::for_each(
v.begin(), v.end(),
__lambda143()
[](float a) { std::cout << a * 3 << " "; } );
}
“closure” instance

24

Closing Angle Brackets

std::vector<std::pair<int, std::string>> x;

25


Error in C++98: >>
tokenized as right-shift


25



OK in C++11

25

Move Semantics
A Really Cheap Lunch

26

Copy Fatigue?
typedef set<string> record;
typedef vector<record> database;

database load_db(string filename);
database db = load_db("huge.db");

db.push_back( create_record() );

27

Copy Fatigue?



• A

27

Copy Fatigue?



• A B

27

Copy Fatigue?



• A B C

27

Copy Fatigue?



• A B C D

27

Copy Fatigue?



• A B C D

A

27

Copy Fatigue?



• A B C D

A B

27

Copy Fatigue?



• A B C D

A B C

27

Copy Fatigue?



• A B C D

A B C D

27

Copy Fatigue?



• A B C D

A B C D

28

Copy Fatigue?



•

A B C D

28

Copy Fatigue?



• A B C D

28

Copy Fatigue?



• A B C D E

28

Copy Fatigue?

database load_db(string filename); Expensive
copies are
made just
before
db.push_back( create_record() ); destroying
the source
object
• A B C D E

28

Try Moving Instead!



• A B C D

29

Try Moving Instead!



• B C D

A

29

Try Moving Instead!



• C D

A B

29

Try Moving Instead!



• D

A B C

29

Try Moving Instead!



•

A B C D

29

Try Moving Instead!



•

A B C D

30

Try Moving Instead!



• A B C D

30

Try Moving Instead!



• A B C D E

30

Move Mini-HOWTO
Move-enabling an existing class

31

Move-Enabling
struct Owner { • X
Owner(const Owner& src)
: p(src.p ? new Resource(*src.p) : 0) {}

Owner& operator=(const Owner& src) {
if (this == &src) return *this;
delete p; p = 0;
if (src.p) p = new Resource(*src.p);
return *this;
}

~Owner() { delete p; }
private:
Resource* p;
};

32

Move-Enabling
: p(src.p ? new Resource(*src.p) : 0) {} X
delete p; p = 0;
return *this;
}

private:
Resource* p;
};

32

Move-Enabling
: p(src.p ? new Resource(*src.p) : 0) {} • X
delete p; p = 0;
return *this;
}

private:
Resource* p;
};

32

Move-Enabling
struct Owner {

if (this == &src) return *this; • Y
delete p; p = 0;
if (src.p) p = new Resource(*src.p); • Z
return *this;
}

private:
Resource* p;
};

33

Move-Enabling
struct Owner {

delete p; p = 0;
if (src.p) p = new Resource(*src.p); •
return *this;
}

private:
Resource* p;
};

33

Move-Enabling
struct Owner {

delete p; p = 0;
if (src.p) p = new Resource(*src.p); • Y
return *this;
}

private:
Resource* p;
};

33

New Move Operations
struct Owner {

delete p; p = 0;
return *this;
}

private:
Resource* p;
};

34

New Move Operations
struct Owner {

Owner& operator=(const Owner& src)

private:
Resource* p;
};

34

New Move Operations
struct Owner {
Owner& operator=(const Owner& src)

private:
Resource* p;
};

34

Move Constructor
struct Owner {
Owner(const Owner& src);
Owner& operator=(const Owner& src);

• X

private:
Resource* p;
};
35

Move Constructor
struct Owner {

Owner(Owner&& src) : p(src.p) { src.p = 0; } • X

private:
Resource* p;
};
35

Move Constructor
struct Owner {

rvalue reference

private:
Resource* p;
};
35

Move Constructor
struct Owner {


•

private:
Resource* p;
};
35

Move Assignment
struct Owner {

Owner(Owner&& src) : p(src.p) { src.p = 0; }

• Y

• Z

private:
Resource* p;
};
36

Move Assignment
struct Owner {


Owner& operator=(Owner&& src) {
• Y
delete p;
p = src.p; src.p = 0; • Z
return *this;
}
private:
Resource* p;
};
36

Move Assignment
struct Owner {


• Y
delete p;
p = src.p; src.p = 0; •
return *this;
}
private:
Resource* p;
};
36

Move Assignment
struct Owner {


•
delete p;
p = src.p; src.p = 0; • Y
return *this;
}
private:
Resource* p;
};
36

Move Semantics

• Automatically accelerates existing code!

• Applied throughout standard library

• Many move-only types in library

• Launches a new era of value semantics

37

Containers
• Move semantics

• Hash containers

• forward_list

• array

• tuple

• Emplace

• Allocators

38

Other Useful Libraries

• regex:

• Algorithms

• function / bind

39

Smart Pointers

• unique_ptr

• shared_ptr

40

Classes and OOP

• member initializers

• explict conversion

• override and ﬁnal

• delegating and inheriting constructors

• defaulted and deleted functions

41

Concurrency

• async, futures, promise

• locks, mutexes and condition variables

• exception propagation

• atomics

42

Templates

• Variadics

• static_assert

• local classes as template arguments

• extern templates

• Template aliases

43

Metaprogramming

• constexpr

• Template aliases

• User-deﬁned literals w/variadic templates

• Type traits and extended SFINAE

44

What’s Next?
• Modules

• Concepts

• Pythy Syntax:

• []min(x, y) { return x < y ? x : y }

45

C++11 (formerly known as C++0x) is the new C++ language standard. Dave Abrahams, BoostPro Computing

More Related Content

What's hot

Viewers also liked

Similar to C++11 (formerly known as C++0x) is the new C++ language standard. Dave Abrahams, BoostPro Computing

More from yaevents

Recently uploaded

C++11 (formerly known as C++0x) is the new C++ language standard. Dave Abrahams, BoostPro Computing