specialization with all actual template arguments specified. It is not possible to create a typedef template. For example: template <typename First, typename Second, int Third> class SomeType; template <typename Second> typedef SomeType<OtherType, Second, 5> TypedefName; // Invalid in C++03 This will not compile. C++11 adds this ability with this syntax: template <typename First, typename Second, int Third> class SomeType; template <typename Second> using TypedefName = SomeType<OtherType, Second, 5>; The using syntax can also be used as type aliasing in C++11: typedef void (*FunctionType)(double); // Old style using FunctionType = void (*)(double); // New introduced syntax Unrestricted unions In C++03, there are restrictions on what types of objects can be members of a union. For example, unions cannot contain any objects that define a non-trivial constructor or destructor. C++11 lifts some of these restrictions. If a union member has a non trivial special member function, the compiler will not generate the equivalent member function for the union and it must be manually defined. This is a simple example of a union permitted in C++11: #include <new> // Needed for placement 'new'. struct Point { Point() {} Point(int x, int y): x_(x), y_(y) {} int x_, y_; }; union U { int z; double w; Point p; // Invalid in C++03; valid in C++11. U() {} // Due to the Point member, a constructor definition is now needed. U(const Point& pt) : p(pt) {} // Construct Point object using initializer list. U& operator=(const Point& pt) { new(&p) Point(pt); return *this; } // Assign Point object using placement 'new'. }; The changes will not break any existing code since they only relax current rules. Core language functionality improvements These features allow the language to do things that were formerly impossible, exceedingly verbose, or needed non-portable libraries. Variadic templates In C++11, templates can take variable numbers of template parameters. This also allows the definition of type-safe variadic functions. New string literals C++03 offers two kinds of string literals. The first kind, contained within double quotes, produces a null-terminated array of type const char. The second kind, defined as L"", produces a null-terminated array of type const wchar_t, where wchar_t is a wide-character of undefined size and semantics. Neither literal type offers support for string literals with UTF-8, UTF-16, or any other kind of Unicode encodings. C++11 supports three Unicode encodings: UTF-8, UTF-16, and UTF-32. The definition of the type char has been modified to