constructor and operator =: class NonCopyable { NonCopyable(); NonCopyable(const NonCopyable&) = delete; NonCopyable& operator=(const NonCopyable&) = delete; }; Type long long int In C++03, the largest integer type is long int. It is guaranteed to have at least as many usable bits as int. This resulted in long int having size of 64 bits on some popular implementations and 32 bits on others. C++11 adds a new integer type long long int to address this issue. It is guaranteed to be at least as large as a long int, and have no fewer than 64 bits. The type was originally introduced by C99 to the standard C, and most C++ compilers supported it as an extension already. Static assertions C++03 provides two methods to test assertions: the macro assert and the preprocessor directive #error. However, neither is appropriate for use in templates: the macro tests the assertion at execution-time, while the preprocessor directive tests the assertion during preprocessing, which happens before instantiation of templates. Neither is appropriate for testing properties that are dependent on template parameters. The new utility introduces a new way to test assertions at compile-time, using the new keyword static_assert. The declaration assumes this form: static_assert (constant-expression, error-message); Here are some examples of how static_assert can be used: static_assert((GREEKPI > 3.14) && (GREEKPI < 3.15), "GREEKPI is inaccurate!"); template<class T> struct Check { static_assert(sizeof(int) <= sizeof(T), "T is not big enough!"); }; template<class Integral> Integral foo(Integral x, Integral y) { static_assert(std::is_integral<Integral>::value, "foo() parameter must be an integral type."); } When the constant expression is false the compiler produces an error message. The first example is similar to the preprocessor directive #error, although the preprocessor does only support integral types. In contrast, in the second example the assertion is checked at every instantiation of the template class Check. Static assertions are useful outside of templates also. For instance, a given implementation of an algorithm might depend on the size of a long long being larger than an int, something the standard does not guarantee. Such an assumption is valid on most systems and compilers, but not all. Allow sizeof to work on members of classes without an explicit object In C++03, the sizeof operator can be used on types and objects. But it cannot be used to do this: struct SomeType { OtherType member; }; sizeof(SomeType::member); // Does not work with C++03. Okay with C++11 This should return