"" _tuffix(); OutputType some_variable = 1234_tuffix; OutputType another_variable = 2.17_tuffix; This instantiates the literal processing function as operator "" _tuffix<'1', '2', '3', '4'>(). In this form, there is no null character terminating the string. The main purpose for doing this is to use C++11's constexpr keyword to ensure that the compiler will transform the literal entirely at compile time, assuming OutputType is a constexpr-constructible and copyable type, and the literal processing function is a constexpr function. For numeric literals, the type of the cooked literal is either unsigned long long for integral literals or long double for floating point literals. (Note: There is no need for signed integral types because a sign-prefixed literal is parsed as an expression containing the sign as a unary prefix operator and the unsigned number.) There is no alternative template form: OutputType operator "" _suffix(unsigned long long); OutputType operator "" _suffix(long double); OutputType some_variable = 1234_suffix; // Uses the 'unsigned long long' overload. OutputType another_variable = 3.1416_suffix; // Uses the 'long double' overload. In accord with the formerly mentioned new string prefixes, for string literals, these are used: OutputType operator "" _ssuffix(const char * string_values, size_t num_chars); OutputType operator "" _ssuffix(const wchar_t * string_values, size_t num_chars); OutputType operator "" _ssuffix(const char16_t * string_values, size_t num_chars); OutputType operator "" _ssuffix(const char32_t * string_values, size_t num_chars); OutputType some_variable = "1234"_ssuffix; // Uses the 'const char *' overload. OutputType some_variable = u8"1234"_ssuffix; // Uses the 'const char *' overload. OutputType some_variable = L"1234"_ssuffix; // Uses the 'const wchar_t *' overload. OutputType some_variable = u"1234"_ssuffix; // Uses the 'const char16_t *' overload. OutputType some_variable = U"1234"_ssuffix; // Uses the 'const char32_t *' overload. There is no alternative template form. Character literals are defined similarly. Multithreading memory model C++11 standardizes support for multithreaded programming. There are two parts involved: a memory model which allows multiple threads to co-exist in a program and library support for interaction between threads. (See this article's section on threading facilities.) The memory model defines when multiple threads may access the same memory location, and specifies when updates by one thread become visible to other threads. Thread-local storage In a multi-threaded environment, it is common for every thread to have some unique variables. This already happens for the local variables of a function, but it does not happen for global and static variables. A new thread-local storage duration (in addition to the existing static, dynamic and