priority over other forms of construction, provided that the initializer list conforms to the sequence constructor's type. The C++11 version of std::vector has an initializer list constructor for its template type. Thus this code: std::vector<int> the_vec{4}; will call the initializer list constructor, not the constructor of std::vector that takes a single size parameter and creates the vector with that size. To access the latter constructor, the user will need to use the standard constructor syntax directly. Type inference In C++03 (and C), to use a variable, its type must be specified explicitly. However, with the advent of template types and template metaprogramming techniques, the type of something, particularly the well-defined return value of a function, may not be easily expressed. Thus, storing intermediates in variables is difficult, possibly needing knowledge of the internals of a given metaprogramming library. C++11 allows this to be mitigated in two ways. First, the definition of a variable with an explicit initialization can use the auto keyword. This creates a variable of the specific type of the initializer: auto some_strange_callable_type = std::bind(&some_function, _2, _1, some_object); auto other_variable = 5; The type of some_strange_callable_type is simply whatever the particular template function override of std::bind returns for those particular arguments. This type is easily determined procedurally by the compiler as part of its semantic analysis duties, but is not easy for the user to determine upon inspection. The type of other_variable is also well-defined, but it is easier for the user to determine. It is an int, which is the same type as the integer literal. This use of the keyword auto in C++ re-purposes the semantics of this keyword, which was originally used in the typeless predecessor language B in a related role of denoting an untyped automatic variable definition. Further, the keyword decltype can be used to determine the type of expression at compile-time. For example: int some_int; decltype(some_int) other_integer_variable = 5; This is more useful in conjunction with auto, since the type of auto variable is known only to the compiler. However, decltype can also be very useful for expressions in code that makes heavy use of operator overloading and specialized types. auto is also useful for reducing the verbosity of the code. For instance, instead of writing for (std::vector<int>::const_iterator itr = myvec.cbegin(); itr != myvec.cend(); ++itr) the programmer can use the shorter for (auto itr = myvec.cbegin(); itr != myvec.cend(); ++itr) which can