C++98 Initial Standard ~7 years C++03 Revised standard Limited to bug fixing ~ 5 years TR1 Pure library extension ~3 years C++11 Significant new features to language and library Many more bug fixes than C++03 ~8 years work

 Work under auspices of ISO SC22 WG21  Typically 5-10 national bodies present at any meeting  More participants online  Meet 2-3 times a year for week-long meetings  Typical attendance in range  4 active working groups  Core  Library  Evolution  Concurrency  Work continues online at a slower pace

> 50 New Language Features New Libraries Built on top of a wider set of standards What’s new? Revised Library for new language Resolved several hundred defect reports Cleaned up presentation What’s changed?

 Concepts  Modules  Reflection  Full-featured Garbage Collection  “No New libraries (beyond TR1)”  TR1 math libraries  Becomes its own standard instead

 export  auto to declare local variables  access declarations  Conversion from string literal to ‘char *’  Converts only to ‘char const *’ now  Reference counted strings

 C99 + TC1 + TC2 + Unicode TR  Unicode  ECMAscript regular expressions  Posix  error handling  threads

New Memory Model Define race conditions Limit optimisations within a single thread Thread local storage Parallel initialization/shutdown Low level primitives atomic operations and fences thread wrappers Mutexes and locks High level primitives Futures asynch

Incidental Programmer Ease of use Syntax cleanup Large Scale systems Program Correctness Expressiveness Interoperability Performance Efficiency Concurrency

Declarations auto alias templates raw string literals UTF8 literals Initialization delegating constructors forwarding constructors member initializers list initialization Facilities garbage collection new for- loop lambda expressions

Simplified rules.template typename right-angle-brackets reference collapsing nested classes are members extended SFINAE Extended syntax Consistent initialization default template parameters for function templates sizeof (non-static) data members linkage for local templates

 explicit override ‘keyword’  nullptr  strong enum  forwarding constructors ('strong' typedef)  static_assert  explicit conversion functions  conditionally supported behavior -> more diagnosable errors  deleted functions  detect array-new overflow  detect narrowing conversions (with new syntax)  noexcept destructors

 New data types  long long  char16_t  char32_t  extended integral types  decltype  auto function declarations  extended friends  extern template  variadic templates  variadic macros  _Pragma  move semantics  perfect forwarding  defaulted functions  user defined literals  initializer lists  attributes  trivial types  fixed-base for enums  forward declare enums  enum class

long Unicode char typesStandard layout typesAlignment specifiersC99 preprocessor

Serial rvalue references constexpr trivial types noexcept final virtual functions alignment control Concurrent memory model thread local storage atomic operations

 inline namespaces  exception cloning  native support for type traits  __func__ and updated assert macro  implicit move constructor  implicit move-assignment operator  reference qualifiers  anonymous namespace has internal linkage  concatenate string literals of different type

 Almost doubled in size (by page count)  Huge effort to clean up specification  Simplify through use of common definitions  More precise contracts, using those terms  Learned a lot from the ‘concept’ experiments  Resolved roughly 6x as many issues as TC1  (although many came from new features as library evolved!)

Incidental Programmer New Library Components Enhanced APIs Large Scale systems Support wider standards Better error detection Enhanced resource management Performance Apply new language features Concurrency

 rvalue references  variadic templates  sequence constructors  constexpr  long long and extended integral types  Unicode character types  explicit bool conversion operators  deleted copy semantics  noexcept  nullptr

 exception cloning  initializer lists  range-based for loop  garbage collection

 shared_ptr  binders  function  array  unordered (hashing) containers  tuple  random numbers  regular expressions  type traits  Adopt C99 library

 unique_ptr and move_iterator  forward_list  atomic primitives  thread launching  thread synchronization  futures and asynch  time interval support  compile-time ratio arithmetic  clocks  portable handling of system errors  nested_exception  type_index

 all_of/any_of/none_of  find_if_not  copy_n/copy_if  move / move_backward  partition_copy  is_partitioned/partition_point  is_sorted/is_sorted_until  is_heap/is_heap_until  next/prev  iota  minmax / minmax_element  variadic min/max/minmax  uninitialized_copy_n

 emplace  cbegin/cend  consistent const_iterator to locate elements  consistent overload on std::string as well as const char *  thread-safe strings (no reference counting)  simple numeric string / std::string conversions  code conversion for wide/narrow strings  new facets : time and money  better floating point support (iostream flags / num limits)  allocator upgrade

 move semantics  random numbers  allocator for shared_ptr/function  shared_ptr aliasing  shared_ptr factories  atomic shared_ptr interface  more type traits : decay/conditional/enable_if  alignment calculators (type traits)  tuple concatenation  equality comparison of hashing containers

 basic thread-safe guarantee through library  Can safely use any library object from a single thread without locking  Sharing an object between threads requires user to synchronize access  Read-only access generally safe without locking, but a single write means reads must synchronize too!  basic_string cannot be copy-on-write  shared_ptr must have thread-safe reference counting  thread-safe access to handler functions, e.g. at_exit

 hidden header dependencies  swap now in rather than  C/C++ std header implementations  allocators  vector  bitset constructors  ios_base::failure derives from system_error

 auto_ptr  old function binders  unary/binary_function

 Most modern compilers implement a subset  static_assert  auto  decltype  rvalue references  lambda  gcc 4.6 has widest support  Clang getting good coverage if you want to build your own