C++ 2011 in haste

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 50-100 range 4 active working groups

Core Library Evolution Concurrency

Work continues online at a slower pace

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

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

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!)

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 <utility> rather than

<algorithm> C/C++ std header implementations allocators vector< bool > 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