c++11 (formerly known as c++0x) is the new c++ language standard. dave abrahams, boostpro computing

C++ 2011Highlights 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

6

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


Type Deduction

7

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


Type Deduction

8



Type Deduction

9

auto a = 3; intconst auto b = 3.14; const doubleauto 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>::iteratorauto& x = l.front(); std::list<Foo>::value_type&

auto& y = any-expression-here;


Type Deduction

10



Range-based for loop

11




12

void print_3x(vector<float> const& v){ for ( float a: v ) { std::cout << a * 3 << " "; }}



12


Range



12


Loop variable Range


auto in C++11Range-based for loop

13

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



14

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



15

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



16

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


Ranges Everywhere

17

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


Ranges Everywhere

18

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


Ranges Everywhere

19

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



20

void print_3x(vector<float> const& v){ BOOST_FOREACH( float a, v ) { std::cout << a * 3 << " "; }}

C++98



20


“ ”C++98



20


“ ”C++98

See your friendly neighborhood Boost C++ Libraries for details


Using an Algorithm

21

void print_3x(vector<float> const& v){ std::for_each( v.begin(), v.end(), );}


Using an Algorithm

21


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


Using an Algorithm

21


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

print_3x_element


Lambda Expressions

22

void print_3x(vector<float> const& v){ std::for_each( v.begin(), v.end(),

);}


Lambda Expressions

22


);}

“Lambda expression”

[](float a) { std::cout << a * 3 << " "; }


Lambda Expressions

23


[](float a) { std::cout << a * 3 << " "; } );}


Lambda Expressions

23


[](float a) { std::cout << a * 3 << " "; } );}

introducer


What It Is

24


[](float a) { std::cout << a * 3 << " "; } );}


What It Is

24


[](float a) { std::cout << a * 3 << " "; } );}

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

anonymous class


What It Is

24


[](float a) { std::cout << a * 3 << " "; } );}

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

__lambda143()

anonymous class

“closure” instance


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

Closing Angle Brackets

25




25

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

Dummy




25

OK in C++11

Dummy


Move SemanticsA Really Cheap Lunch

26


typedef set<string> record;typedef vector<record> database;

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

db.push_back( create_record() );

Copy Fatigue?

27





Copy Fatigue?

27

• A





Copy Fatigue?

27

• A B





Copy Fatigue?

27

• A B C





Copy Fatigue?

27

• A B C D





Copy Fatigue?

27

• A B C D

A





Copy Fatigue?

27

• A B C D

A B





Copy Fatigue?

27

• A B C D

A B C





Copy Fatigue?

27

• A B C D

A B C D





Copy Fatigue?

28

• A B C D

A B C D





Copy Fatigue?

28

•

A B C D





Copy Fatigue?

28

• A B C D





Copy Fatigue?

28

• A B C D E





Copy Fatigue?

28

• A B C D E

Expensive copies are made just

before destroying the source

object





Try Moving Instead!

29

• B C DA





Try Moving Instead!

29

• B C D

A





Try Moving Instead!

29

•

B

C D

A





Try Moving Instead!

29

•

B C

D

A





Try Moving Instead!

29

•

B C DA





Try Moving Instead!

30

•

A B C D





Try Moving Instead!

30

• A B C D





Try Moving Instead!

30

• A B C D E


Move Mini-HOWTOMove-enabling an existing class

31


X

Move-Enabling

32

struct Owner { 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;};

• X


X

Move-Enabling

32




• X

•


Y

Move-Enabling

33




• Y

• Z


Y

Move-Enabling

33




• Y

•


New Move Operations

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

34

struct Owner { Owner(const Owner& src)


Owner& operator=(const Owner& src)

: p(src.p ? new Resource(*src.p) : 0) {}


New Move Operations

34

struct Owner { Owner(const Owner& src)


Owner& operator=(const Owner& src)


Move Constructor

35

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


X• X


Move Constructor

35



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

X• X


Move Constructor

35




X• X

rvalue reference


Move Constructor

35




X• X


Move Constructor

35




•

X• X


Move Constructor

35




•

X• X

•


Move Assignment

36




Y•

• Z


Move Assignment

36




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

Y•

• Z


Move Assignment

36





Y•

•


Move Assignment

36





Y

•

•


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 final

• 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-defined 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

Technology

better language

little features

new algorithms features

iterator p

template aliases

writing libraries

new international standard

regular expressions