herb sutter. c/c++ 7.0 feb 1992 vc++11 beta: feb 2012 arm targeting win8 tablet apps c++ amp...
TRANSCRIPT
C++11, VC++11, and Beyond
Herb Sutter
20 Year Anniversary
C/C++ 7.0Feb 1992
VC++11Beta: Feb 2012
ARM targetingWin8 tablet apps
C++ AMPComplete C++11 stdlib
C++ AMPPr
oces
sors
MemoryUnified Disjoint
(tight)NUMA cache NUMA RAM Incoherent /
weak
Complex OoO
Simple InO
Specialized(X)
Specialized(Y)
Disjoint (loose)
C++, not C
mainstream, programmable by millions
minimal, just one general language extension
portable, mix & match hardware from any vendor, one EXE
general and future-proof, designed to cover the full range of hardware heterogeneity – hardware is still in motion
open specification
June 2011
C++ AMP Open Specification
Todayblogs.msdn.com/nativeconcurrency/
VC++ & C++11
VC11Beta
VC11RTM
OOBCTP
OOBRTM
Feb2012
+ C++11range-for,
final,override
Out-Of-BandReleases
+ progressively roll out C++11 initializer lists, template
aliases, variadic templates, constexpr, noexcept,
=default/delete, …
VC11DP
Sep2011
+ completeC++11 stdlib:
thread/mutex,async, future, …+ track changes
(lambdas, &&, …)
You arehere
VC10RTM
Apr2010
+ lambdas, move/&&,
auto, decltype,auto fn decls,
extern template,nullptr, … Survey: bit.ly/mscpp11
Roadmap
“C++11 feels like a new language.” The most pervasive features. Style, idioms, and guidance.
C++11 adoption scorecard. How are we doing? Learning, compilers, and books.
What’s next for ISO C++?
“C++11 Feels Like a New Language” Great! But significant change to coding style/idioms/guidance.
That’s why it feels new. Style/idioms/guidance define a language. Features that significantly change style/idioms/guidance include:
Core Languageauto nullptrrange-for lambdasmove semantics, rvalue references
uniform initialization, initializer lists
noexcept constexpr
Librarysmart pointersbegin(x) / end(x)
auto
auto
Still static. Simpler. Generic/robust. Handles unutterable types. Just use auto. Unless you explicitly want to state a type conversion:
Such as to not capture an “ephemeral” type:auto x = make_valarray(1) + make_valarray(2); // oopsauto y = _1 = 1; /* Boost.Lambda */ // oopsauto z = { 42 }; // oops
C++98 C++11
map<int,string>::iterator i = m.begin();double const xlimit = config["xlimit"];singleton& s = singleton::instance();
auto i = begin(m);auto const xlimit = config["xlimit"];auto& s = singleton::instance();
binder2nd<greater> x = bind2nd( greater(), 42 ); auto x = [](int i) { return i > 42; };
Nothing new here
Exactly the same as
template arg deduction
Uniform Initialization and initializer_lists
{ }
Uniform Initialization and initializer_listsC++98
rectangle w( origin(), extents() );complex<double> c ( 2.71828, 3.14159 );int a[] = { 1, 2, 3, 4 };vector<int> v;for( int i = 1; i <= 4; ++i ) v.push_back(i);
Uniform Initialization and initializer_listsC++98 C++11
rectangle w( origin(), extents() );complex<double> c ( 2.71828, 3.14159 );int a[] = { 1, 2, 3, 4 };vector<int> v;for( int i = 1; i <= 4; ++i ) v.push_back(i);
rectangle w { origin(), extents() };complex<double> c { 2.71828, 3.14159 };int a[] { 1, 2, 3, 4 };vector<int> v { 1, 2, 3, 4 };
Uniform Initialization and initializer_listsC++98 C++11
rectangle w( origin(), extents() );complex<double> c ( 2.71828, 3.14159 );int a[] = { 1, 2, 3, 4 };vector<int> v;for( int i = 1; i <= 4; ++i ) v.push_back(i);
rectangle w { origin(), extents() };complex<double> c { 2.71828, 3.14159 };int a[] { 1, 2, 3, 4 };vector<int> v { 1, 2, 3, 4 };
int i = 42; int i = 42;auto x = begin(v);
Uniform Initialization and initializer_listsC++98 C++11
rectangle w( origin(), extents() );complex<double> c ( 2.71828, 3.14159 );int a[] = { 1, 2, 3, 4 };vector<int> v;for( int i = 1; i <= 4; ++i ) v.push_back(i);
rectangle w { origin(), extents() };complex<double> c { 2.71828, 3.14159 };int a[] { 1, 2, 3, 4 };vector<int> v { 1, 2, 3, 4 };
int i = 42; int i = 42;auto x = begin(v);
draw_rect( rectangle( obj.origin,selection.extents ) );
draw_rect( { obj.origin, selection.extents } );
Uniform Initialization and initializer_lists Use {} unless you have a reason not to.
“Unless” you prefer convenience with simple initialization or auto.int i = 42; // just too ingrained…auto x = begin(v);
“Unless” you need to construct with args that would be a valid initializer_list.vector<int> v( 100 ); // 100 ints (a similar odd case in C++98 got a magic rule)vector<int> v{ 100 }; // one element of value 100
“Unless” you don’t want auto to capture initializer_list.int n; // Richard Smith’s exampleauto w(n); // intauto x = n; // intauto y { n }; // std::initializer_list<int>auto z = { n }; // std::initializer_list<int>
for, begin, end
for, begin, end
Range-for: Just use it. Remember auto& if you want to avoid a copy.
Prefer begin(x)/end(x). They’re adaptable to non-STL containers. Define your own to adapt a container type. (C++11 does this for arrays.)
C++98 C++11
for( vector<int>::iterator i = v.begin(); i != v.end(); ++i ) { total += *i;}
for( auto d : v ) { total += d;}
sort( v.begin(), v.end() );sort( &a[0], &a[0] + sizeof(a)/sizeof(a[0]) );
sort( begin(v), end(v) );sort( begin(a), end(a) );
cbegin, cend An oversight:
find_if( begin(v), end(v), ::: ); // C++11find_if( cbegin(v), cend(v), ::: ); // not C++11 (yet)
This will be fixed.
For now, write them yourself.template<class T>auto cbegin( const T& t ) -> decltype( t.cbegin() ) { return t.cbegin(); }template<class T>auto cend( const T& t ) -> decltype( t.cend() ) { return t.cend(); }
Smart Pointers
standard and portable memory safety
Smart Pointers
Use shared_ptr to express shared ownership, and weak_ptr to express shared observation (e.g., cycle-breaking, optionality). Use make_shared and gotw102::make_unique. Avoid “new.”
Use a non-owning * or & to observe an object that will outlive you.
C++98 C++11widget* pw = new widget();delete pw;
auto pw = make_shared<widget>();
class node { vector<node*> children; node* parent;
class node { vector<unique_ptr<node>> children; node* parent;
DELETE
make_unique An oversight:
auto p1 = make_shared<widget>(); // C++11auto p2 = make_unique<widget>(); // not C++11 (yet)
This will be fixed.
For now, write it yourself.template<typename T, typename ...Args>std::unique_ptr<T> make_unique( Args&& ...args ){ return std::unique_ptr<T>( new T( std::forward<Args>(args)... ) );}
Parameters: “Pass Expensive Objects By &”
Default: Agnostic to object’s lifetime policy.void f( widget* w );void f( widget& w ); // or &&
When you want to commit to shared_ptr lifetime:void f( const shared_ptr<widget>& w ); // (see next two slides…)
Pessimization (don’t do this):void f( shared_ptr<widget> w ); // atomic inc+dec
Smart Pointer & Params, Note 1 What if we modify a smart pointer passed by reference, and there’s an alias to
the object that the shared_ptr is supposed to keep alive?
shared_ptr<widget>& g_spw;f( g_spw, *g_spw );
void f( /*non-const*/ shared_ptr<widget>& spw, widget& w ) { ::: spw = some_other_widget; // oops w.draw(); // boom (if g_spw was the last) :::}
Solution: Pass by const&.
Smart Pointer & Params, Note 2 What if we modify the original object that was passed, and there’s an alias to
the object that the shared_ptr is supposed to keep alive?
shared_ptr<widget>& g_spw;f( g_spw, *g_spw );
void f( const shared_ptr<widget>& spw, widget& w ) { spw->draw(); // ok g_spw = some_other_widget; // oops w.draw(); // boom (if g_spw was the last) spw->draw(); // + no longer the same widget}
Solution: “Don’t do that.”
Move Semantics and &&
the semantics of value types (no pointers! lifetime!)
+the efficiency of reference types
Move Semantics and &&
Move is an optimization of copy (and enables perfect forwarding). Use return by value to express “callee-allocated out.”
No change in guidance for “caller-allocated out.”
C++98 C++11// no copy, but don’t forget to deletevector<int>* make_big_vector();
// no copy, but commit to shared_ptr/refcntshared_ptr<vector<int>> make_big_vector();
// Use this for “callee-allocated out”vector<int> make_big_vector();
// callee-allocated outvoid make_big_vector( vector<int>& out );
// callee-allocated outvoid make_big_vector( vector<int>& out );
References are Still References Note: You wouldn’t do this: or this:
widget& f() { widget* f() { widget w; widget w; ::: ::: return w; return &w;} }
So of course do this: not this (common initial mistake):widget f() { widget&& f() { widget w; widget w; ::: ::: return w; return w;} }
NB: Returning a local or param treats it as an rvalue (it’s about to be destroyed).
Lambdas
pass code around like an object
loop bodiespredicatescallbacks
(and ~100 other examples)
Lambdas
“Lambdas, Lambdas Everywhere” http://vimeo.com/23975522
C++98 C++11
vector<int>::iterator i = v.begin();for( ; i != v.end(); ++i ) { if( *i > x && *i < y ) break;}
auto i = find_if( begin(v), end(v), [=](int i) { return i > x && i < y; } );
Algorithms++ Did you just write a new algorithm? Example: for_each with step.
template<class Coll, class Func>void for_each_nth( Coll& coll, step s, Func func );
Congratulations! You’ve also written a new kind of loop.for_each_nth( v, 3, [] ( Widget& w ) { // for every 3rd element in v… :::} );
Great for parallel algorithms – without new language extensions.parallel_for_each( std::begin(v), std::end(v), [=](int i) { Foo( a[i] );} );
Again: References are Still References Note: You wouldn’t do this: or this:
widget& f() { widget* f() { widget w; widget w; ::: ::: return w; return &w;} }
So of course do this: not this: or this:function<void()> f() { function<void()> f() { void f() { widget w; widget w; widget w; ::: ::: async( [&w](){ g(w); } ); return [w](){ g(w); }; return [&w](){ g(w); }; :::} } }
Clean, Safe, Fast
With C++11, modern C++ code is clean, safe, and fast.
As clean and safe as any other modern language. When used in a modern style.
Was always fast. Now even faster. Move semantics, constexpr.
Roadmap
“C++11 feels like a new language.” The most pervasive features. Style, idioms, and guidance.
C++11 adoption scorecard. How are we doing? Learning, compilers, and books.
What’s next for ISO C++?
We’re All Learning C++11 The world is still in the early stages of gaining field experience using the
new language features, individually and together. Includes everyone: WG21 members, authors, developers.
Example: Move semantics. 2002-09-10: N1377, Initial move proposal. (Hinnant, Dimov, Abrahams) 2011-11-09: “We are still in an infancy stage with regard to having a good
working knowledge of how to use rvalue refs. I would very much like us to strongly consider field experience in nailing down corner cases like this.” (Hinnant)
A few more: cbegin(x)/cend(x), uniform initialization guidance, range-for lookup.
Libraries, Compilers, and Books: Oh My? Using C++11: Implementations.
C++11 library: Several available now or soon (2012). C++11 language: First reasonably fully conforming compiler in 2013?
Learning C++11: Books and other materials. Scott Meyers’ “Overview of the New C++ (C++11)” – bit.ly/meyers11 ETAs for the major books…
C++ Primer (Moo) Aug 2012 ReferenceThe C++ Programming Language (Stroustrup) Late 2012 ReferenceProgramming: Principles & Practice Using C++ (Str.) Late 2013? IntroductoryEffective C++ (Meyers) 2013-14? Style guidanceC++ Coding Standards (Sutter, Alexandrescu) 2015? Established guidance
Roadmap
“C++11 feels like a new language.” The most pervasive features. Style, idioms, and guidance.
C++11 adoption scorecard. How are we doing? Learning, compilers, and books.
What’s next for ISO C++?
Suggestion: Preserve Style/Idiom/Guidance Can still remove reasons to resort to preprocessor macros
(they’re outside the language anyway). Example: “#once” to replace #include guard macros.
Can still remove reasons to resort to template metaprogramming (arguably outside language, inaccessible to most developers anyway). Example: “static if” to replace specialization/termination/SFINAE.
Can still make usability improvements to existing features (e.g., simpler spelling or wider use, not new style/idiom/guidance). Polymorphic lambdas.
[]( some_typename& x ) { return x.f() + g(x); } []( auto& x ) { return x.f() + g(x); }
[]( x ) { x.f() + g(x) }
Q: What is Standard C++’sbiggest weakness?
C++11
C++98 + TR1C++11
Portable C++
C++98 C++98
language
C11C11
library
C99C99
C90 C90K&RK&R
proxies for size comparisons: spec #pages, book #pages
proxies for size comparisons: spec #words library #types (non-‘plumbing’)
2008 .NET FX + VS Pro Libs
Java SE 7
C++11
Portable C++language
C# 3.0 (2008)Java 7 (2011)
2008 .NET FX (only)
C++11
library
2008 .NET FX + VS Pro Libs
Java SE 7
C++11
C# 3.0 (2008)Java 7 (2011)
2008 .NET FX (only)
C++11
language library
Portable C++
2008 .NET FX + VS Pro Libs
Java SE 7
C++11
C# 3.0 (2008)Java 7 (2011)
2008 .NET FX (only)
Portable C++
C++11
language library
C++11
C# 3.0 (2008)Java 7 (2011)
Portable C++
?C++11
library“All in all, this [C++0x and post-C++0x library wish lists] … is not quite the
‘ambitious and opportunistic’ policy that I had hoped for in 2001 (§8). However, people who scream for more (such as me) should note
that even what’s listed above will roughly double the size of the
standard library.”
– B. Stroustrup, HoPL-III, 2007
Portable C++ Library (PCL) Goals:
Large set of useful and current libraries. Available on all major platforms. Shipped with and supported by C++ implementations. And composable, using consistent types.
Minimum: De facto availability as part of all major compiler products. Ideal: De jure inclusion in Standard C++.
Wonderful! But… … where are we going to find all these libraries?
WG21
PCL
PCL Scope Do focus on pure libraries. Do focus on common modern tasks with state-of-the-art existing practice.
Lower-level: Message queue, ranges + range algorithms, parallel algorithms, thread-safe containers, continuations (future.then), async I/O, file system, networking/sockets, serialization.
Higher-level: REST web services, sensor fusion, HTTP, HTML, XML/XSLT, JSON, persistence, settings/preferences, compression, cryptography, audio/image/video, databases, SMS messaging.
Don’t target niche uses. (Example: Sci-eng linear algebra.) Don’t become a platform = fat libs that duplicate native services. Don’t attempt to define a “portable cross-platform” library that will be
inferior to a native platform app. (Example: GUI WIMP widgets.)
Roadmap
“C++11 feels like a new language.” The most pervasive features. Style, idioms, and guidance.
C++11 adoption scorecard. How are we doing? Learning, compilers, and books.
What’s next for ISO C++?
Questions?