C++ in the 21st Century

C++ in the 21st Century
arvid@bittorrent.com
September 2013
For Internal Presentations Only, Not For External Distribution.

For Internal Presentation Purposes Only, Not For External Distribution .BitTorrent, Inc. | C++ in the 21st Century
C++11
• for loops
• automatic type deduction
• lambda functions
• override speciﬁer
• smart pointers
• error_code
• chrono

•  for loops
•  automatic type deduction
•  lambda functions
•  override speciﬁer
•  smart pointers
•  error_code
•  chrono library features
core language features
C++11

for (std::vector<int>::iterator i = v.begin()!
, end(v.end()); i != end; ++i) {!
print(*i);!
}!
int v[] = {1, 3, 3, 7};!
for (int i = 0; i < sizeof(v)/sizeof(v[0]); ++i) {!
print(v[i]);!
}!
C++98

for (int a : v) {!
print(a);!
}!
C++11 For

for (auto i = begin(v), _end(end(v));!
i != _end; ++i) {!
int a = *i;!
print(a);!
}!
Conceptually expands to something like this:
C++11 For

Conceptually expands to something like this:
argument dependent lookup,
to support user deﬁned types
for (auto i = begin(v), _end(end(v));!
i != _end; ++i) {!
int a = *i;!
print(a);!
}!
C++11 For

template<class A, int N>!
A* begin(A a[N]) { return &a[0]; }!
!
template<class A, int N>!
A* end(A a[N]) { return &a[N]; }!
!
This is why it also works for C-arrays
C++11 For

for loops
automatic type deduction
lambda functions
override speciﬁer
smart pointers
error_code
chrono
C++11 For

New use of keyword auto - automatically deduces the type
of a variable declaration.
New keyword decltype() - deduces the type of an
expression. This can be used in type expressions other than
variable declarations, such as template arguments.
C++11 Auto

C++11 Declytype
std::vector<decltype(f())> vals;!
std::generate_n(std::back_inserter(vals), 10, &f);!

std::vector<decltype(f())> vals;!
std::generate_n(std::back_inserter(vals), 10, &f);!
f() is not evaluated, similar to sizeof().
decltype expression is a type
C++11 Declytype

std::map<std::string, int> m;!
!
std::map<std::string, int>::iterator i =!
m.find(“foobar”);!
if (i == m.end()) return;!
C++98 Auto

!
auto i = m.find(“foobar”);!
C++11 Auto

!
Type deduced from return
type of function call
C++11 Auto

!
conceptually: decltype(m.ﬁnd(“foobar”)) i = ...
C++11 Auto

• for loops
• error_code
• chrono
C++11 Auto

C++98 Function objects
struct is_divisible_by {!
is_divisible_by(int denom): d(denom) {}!
bool operator()(int n) const!
{ return n % d == 0; }!
int d;!
}!
!
std::vector<int>::iterator i =!
std::find_if(v.begin()!
, v.end(), is_divisible_by(x));!

bool is_divisible_by()(int n, int d)!
{ return n % d == 0; }!
!
, v.end(), std::bind(&is_divisible_by, _1, x));!

bool is_divisible_by()(int n, int d)!
{ return n % d == 0; }!
!
, v.end(), std::bind(&is_divisible_by, _1, x));!
Partially applied function

auto i = std::find_if(v.begin()!
, v.end(), [=](int n) { return n % x == 0; });!

• New syntax for lambda functions.
• Expressions that implicitly create function objects
that captures referenced values from the scope.
• Values can be captured by value, by reference or both

std::vector<int> v = {1,2,3,4,5,6,7};!
int x = 2;!
auto i = std::find_if(v.begin()!
, v.end(), [=](int n) { return n % x == 0; });!
copy x into lambda scope
capture expression (copy)

[=](int n) { return n % x == 0; });!
copy captured variables from context
!
!
[&](int n) { return n % x == 0; });!
capture context variables by reference (lvalues)
!
!
[&x](int n) { return n % x == y; });!
explicitly capture x by reference, anything else is
captured by copy

auto i = std::transform(v.begin(), v.end()!
, [=](double n) -> double!
{ if (n < 0.1) return 0; else return n; });!
!
!
If the compiler fails to deduce return type for the lambda, it can
be speciﬁed with the -> syntax.

• for loops
• error_code
• chrono
C++11

C++11 Override specifier
struct shape { virtual void draw(); };!
!
struct rectangle : shape!
{ virtual void draw() const; };!

!
{ virtual void draw() const; };!
Does not override shape’s draw!
C++11 Override specifier

!
{ virtual void draw() const override; };!
tell the compiler that we want this to
override a function from the base class
Error: Has a different signature
from ‘shape::draw’!

C++11 Final specifier

struct shape : entity!
{ virtual void move(); };!
!

struct shape : entity!
{ virtual void move() final; };!
!
not allowed to be overridden!

Error: move cannot be overridden as
it's final in ‘shape’!


template <class T> unique_ptr<T>;!
delete object when pointer goes out of scope. pointer
is not copyable (but movable).
replaces the somewhat broken std::auto_ptr<T>.
Useful for returning heap allocated objects and
constructing temporary heap objects.
C++11 Smart pointers

std::unique_ptr<A> a = new A;!
!
a->foo();!
a->bar();!
!
// a is deleted at the end of the scope
// typically one would just create A
// on the stack in this case

std::unique_ptr<shape> get_new_shape() {!
switch (std::rand() % 2) {!
case 0: return new rectangle();!
case 1: return new circle();!
}!
}!
!
users of this function do not need to think about object
ownership or lifetime.

template <class T> shared_ptr<T>;!
delete object when last pointer goes out of scope.
pointer is copyable and reference counting.
template <class T> weak_ptr<T>;!
non reference counting pointer to object held by
shared_ptr.
template <class T, ...A>!
shared_ptr<T> make_shared(A... args);!
constructs an instance of T held by a shared_ptr.

shared_ptr<socket> c = make_shared<socket>();!
c->connect(/* ... */);!
c->async_read([=] (size_t, error_code const&)!
{ c->async_write(...); });!
// as long as the operation is outstanding,
// the connection object is kept alive

Using an integer for errors:
+ easy to programmatically handle errors
+ error message can be localized
- which domain does the error belong to (posix,
http, openssl, windows, ...)
- not easily interpreted by human (especially
with domain unknown)
C++11 Error_code

Using a string for errors:
+ easily interpreted by humans
- hard to programmatically handle errors
- which domain does the error belong to?
(not clear unless the string is verbose)
- essentially impossible to localize
C++11 Error_code

error_code represents an error and solves all of those
problems.
error_code has an integral error_value, indicating the error
as well as a category, indicating the domain of the
error_value.
category is an abstract base class implementing error_value -
> human error message.
category is critical for compossibility.
C++11 Error_code

tcp::socket s;!
error_code ec;!
s.connect(/* ... */, ec);!
if (ec) {!
printf(“failed to connect: [%s:%d] %sn”!
, ec.category().name()!
, ec.value()!
, ec.message().c_str());!
exit(1);!
}!
!
!
C++11 Error_code

using an error_code for errors:
!
+ easily interpreted by humans!
+ easy to programmatically handle errors!
+ clear which domain the error belongs to!
+ possible to localize!
C++11 Error_code

Nanosecond resolution and millennia range of timestamps?
(both do not ﬁt in 64 bits)
Separate functions for second, millisecond, microsecond
resolution clocks?
Floating point timestamps?
Type safety of timestamps?
(pass in microseconds to a sleep that takes milliseconds, then wait...)
C++11 Chrono

in C++98 and POSIX, we have the following timers:
std::clock() / CLOCKS_PER_SEC
time()
clock_gettime() / clock_getres()
gettimeofday()
C++98 Chrono

in C++98 and POSIX, we have the following timers:
std::clock() / CLOCKS_PER_SEC
time()
clock_gettime() / clock_getres()
gettimeofday()
nanosecond resolution,
but is not monotonic (daylight
savings, ntpd adjustments)
high resolution and
monotonic. not supported on
windows and some POSIX
very low resolution
second resolution, not monotonic
C++98 Chrono

Chrono introduces an abstract concept of a clock,
with its own epoch and its own resolution.
time_point - a point in time, relative to the epoch
time_duration - a delta between two time points,
a certain number of ticks.
C++11 Chrono

To query the current time:
clock::time_point timestamp = clock::now();
C++11 provides 3 standard clocks:
std::chrono::system_clock - real-time clock
std::chrono::steady_clock - guaranteed to be monotonic
std::chrono::high_resolution_clock - system’s highest resolution
C++98 Chrono

the time_point and time_duration types have their resolution
encoded in their types.
duration<int,ratio<1,1000000000>> nanoseconds;!
duration<int,ratio<1,1000000>> microseconds;!
duration<int,ratio<1,1000>> milliseconds;!
duration<int,ratio<1,1>> seconds;!
duration<int,ratio<60,1>> minutes;!
duration<int,ratio<3600,1>> hours;!
C++11 Chrono

conversion of resolution is automatic, i.e. you have type safety
void sleep(milliseconds s);!
sleep(seconds(10)); // OK!!
C++11 Chrono

duration<int,ratio<1,3>> d1(1); // 1 tick of 1/3 second!
duration<int,ratio<1,5>> d2(1); // 1 tick of 1/5 second!
!
auto d = d1 + d2;!
// yields 8 ticks of 1/15th seconds!
// duration<int,ratio<1,15>> d(8);!
!
d2 < d1 // yields true!
C++11 Chrono

range-for: for (int a : v) { printf(“%dn”, a); }!
keywords: auto decltype override final!
lambda: [=](int x) { return x % n == 0; }!
smart ptrs: shared_ptr<> make_shared<> unique_ptr<>!
types: error_code, time_point, time_duration!
Thank You
C++11

C++ in the 21st Century

Recommended

Recommended

More Related Content

Similar to C++ in the 21st Century

Similar to C++ in the 21st Century (20)

Recently uploaded

Recently uploaded (20)

C++ in the 21st Century

Editor's Notes