underlying type is specified explicitly. enum class Enum3; // Valid in C++11, the underlying type is int. enum class Enum4 : unsigned int; // Valid in C++11. enum Enum2 : unsigned short; // Invalid in C++11, because Enum2 was formerly declared with a different underlying type. Right angle bracket C++03's parser defines “>>” as the right shift operator or stream extraction operator in all cases. However, with nested template declarations, there is a tendency for the programmer to neglect to place a space between the two right angle brackets, thus causing a compiler syntax error. C++11 improves the specification of the parser so that multiple right angle brackets will be interpreted as closing the template argument list where it is reasonable. This can be overridden by using parentheses around parameter expressions using the “>”, “>=” or “>>” binary operators: template<bool Test> class SomeType; std::vector<SomeType<1>2>> x1; // Interpreted as a std::vector of SomeType<true>, // followed by "2 >> x1", which is not valid syntax for a declarator. 1 is true. std::vector<SomeType<(1>2)>> x1; // Interpreted as std::vector of SomeType<false>, // followed by the declarator "x1", which is valid C++11 syntax. (1>2) is false. Explicit conversion operators C++98 added the explicit keyword as a modifier on constructors to prevent single-argument constructors from being used as implicit type conversion operators. However, this does nothing for actual conversion operators. For example, a smart pointer class may have an operator bool() to allow it to act more like a primitive pointer: if it includes this conversion, it can be tested with if (smart_ptr_variable) (which would be true if the pointer was non-null and false otherwise). However, this allows other, unintended conversions as well. Because C++ bool is defined as an arithmetic type, it can be implicitly converted to integral or even floating-point types, which allows for mathematical operations that are not intended by the user. In C++11, the explicit keyword can now be applied to conversion operators. As with constructors, it prevents using those conversion functions in implicit conversions. However, language contexts that specifically need a boolean value (the conditions of if-statements and loops, and operands to the logical operators) count as explicit conversions and can thus use a bool conversion operator. For example, this feature solves cleanly the safe bool issue. Template aliases In C++03, it is possible to define a typedef only as a synonym for another type, including a synonym for a template