C++11新增语法特性及标准库简介

1. core language features

1.1. C99 preprocessor

C99的预处理器宏可以支持一些复杂的操作，VS2015支持部分特性，VS2019支持更多。很多大型C项目，像CPython、ffmpeg等，需要支持C99，所以需要使用VS2019编译。C++程序员，一般少用宏，尤其是复杂的宏。

1.2. static_assert

执行编译时的断言检测，提前发现问题，降低Bug修复成本。VS2010及之后的版本支持此特性。
C++11中的static_assert是一种编译时断言，它允许程序员检查模板参数或其他编译时常量的属性。如果条件失败，它会停止编译并生成一个编译器错误信息。它的语法是 static_assert(condition, message)

static_assert((sizeof(var) >= 4), "Error");

1.3. Right angle brackets

typedef std::vectorstd::vector Flags;C++11之前，右边的>>需要空格才可以。
在C++11中，右尖括号（>）可以用于表示模板参数，而无需在它们之间添加空格。这被称为“右边角括号”问题，其中编译器会将两个连续的尖括号（>>）解释为右移运算符，而不是模板参数的关闭尖括号对。

例如，您可以使用以下语法：

std::vector<std::vector<int>>

而不是以下语法：

std::vector<std::vector<int> >

这使代码更易于阅读，并避免了由双尖括号的歧义可能引起的错误。
VS2005及之后的版本支持此特性。

1.4. Extended friend declarations

C++11引入了扩展友元声明（Extended friend declarations）的新特性，可以更加灵活地定义友元。VS2013及之后的版本支持此特性。示例如下：

class C;
typedef C Ct;
class X1 {
friend C; // OK: class C is a friend
};
class X2 {
friend Ct; // OK: class C is a friend
friend D; // error: no type-name D in scope
friend class D; // OK: elaborated-type-specifier declares new class
};

1.5. long long

long long占用8个字节（64位），可以表示的整数范围是从-9,223,372,036,854,775,808到9,223,372,036,854,775,807。VS2005及之后的版本支持此特性。

1.6. Compiler support for type traits

可以用来判断类型状态，有**has_virtual_destructor、**is_base_of等函数。VS2015及之后的版本支持此特性。

// has_virtual_destructor.cpp
#include 
struct S {
   virtual ~S() {}
};
int main() {
   __has_virtual_destructor(S) == true ? 
      printf("true\n") : printf("false\n");
}

// is_base_of.cpp
#include 
struct S {};
struct T : public S {};
int main() {
   __is_base_of(S, T) == true ? 
      printf("true\n") : printf("false\n");
   __is_base_of(S, S) == true ? 
      printf("true\n") : printf("false\n");
}

1.7. auto

原先用于声明自动变量的功能被废除，新功能为修改变为通过变量的初始化值来推导出变量的类型。
VS2010及之后的版本支持此特性。新功能简单示例：

auto x = 5; // ok, x has type int
const auto *v = &x, u = 6; // ok, v has type const int*, u has type const int
static auto y = 0.0; // ok, y has type double
static auto int z; // ill−formed, auto and static conflict
auto int r; // ok, r has type int

1.8. Delegating constructors

类可能有很多构造函数，有时一个构造函数的功能其实是在另一个构造函数的功能之上再添加一点新的功能。
传统的方法下，如果想共用相同的代码，必须将相同代码抽象为一个函数，然后再共用。VS2013及之后的版本支持此特性。
有没有更方便的方法呢？C++11中提出的委托构造函数，可以实现相关功能。

class Foo
{
public: 
    Foo(char x, int y) {}
    Foo(int y) : Foo('a', y) {} // Foo(int) delegates to Foo(char, int)
};

1.9. extern template

extern template 是 C11 中的一个特性，用于显式实例化模板。在 C 中，模板可以提供泛型编程支持，但在不同的编译单元中，对同一个模板进行实例化会带来一些问题，例如代码膨胀和编译时间增加等。VS2010及之后的版本支持此特性。
为了解决这个问题，C++11 引入了 extern template 关键字，它允许将模板的实例化推迟到其他编译单元中。具体来说，使用 extern template 可以将模板实例化放在一个编译单元中，并在其他编译单元中使用 extern template 声明来避免重复实例化。
以下是一个示例代码：

// test.h
template <typename T>
class Test {
public:
    void func();
};

// test.cpp
#include "test.h"
template <typename T>
void Test<T>::func() {
    // Implementation here...
}
template class Test<int>;
template class Test<double>;

// main.cpp
#include "test.h"
extern template class Test<int>;
int main() {
    Test<int> t;
    t.func();
    return 0;
}

在上述示例代码中，我们首先定义了一个名为 Test 的类模板，在 test.cpp 文件中实例化了该模板，并在 main.cpp 文件中使用 extern template 关键字声明了 Test 的实例化。这样做可以避免在 main.cpp 编译时再次实例化 Test，从而加速编译过程并减少代码膨胀。

1.10. constexpr

constexpr是C++11中新引入的指示符，允许函数和变量在编译时计算出值，可以大幅提升代码性能。例如，斐波那契数列的计算，可以直接在编译时计算出来。如下图，factorial函数直接被编译为表格，直接查表获取。VS2015及之后的版本支持此特性。

1.11. Template aliases

C++11引入了模板别名（Template aliases）功能，可以使用using关键字来定义一个模板别名。它允许程序员为现有的类型或模板起一个新的名称，以方便使用和提高代码的可读性。VS2013及之后的版本支持此特性。
以下是一个示例代码：

template<typename T>
using Vec = std::vector<T>; // 定义一个模板别名Vec，表示std::vector

int main()
{
    Vec<int> v{1, 2, 3}; // 使用Vec作为std::vector的别名
    for (auto i : v)
        std::cout << i << ' ';
}

1.12. char16_t and char32_t

C++11引入了两个新的字符类型：char16_t和char32_t。它们分别用于表示16位和32位的Unicode字符，以支持国际化和本地化应用程序开发。VS2015及之后的版本支持此特性。
char16_t表示一个16位的Unicode字符，类似于wchar_t，但是其大小是固定的。可以使用u前缀来表示一个char16_t字符常量，例如：

char16_t c = u'中';

char32_t表示一个32位的Unicode字符，也可以使用U前缀来表示一个char32_t字符常量，例如：

char32_t c = U'';

在实际开发中，如果需要使用Unicode字符集，建议使用char16_t和char32_t，避免出现字符编码问题。但是，在处理ASCII字符时，仍然可以使用标准的char类型。

1.13. alignas

早期的内存对齐，不同编译有不同的方式，不统一。C++11中，alignas是一个新的关键字，用于控制内存对齐方式。它可以让程序员指定一个对象或变量的对齐方式，以便更好地利用硬件特性提高程序效率。VS2015及之后的版本支持此特性。
例如，以下代码使用alignas关键字声明一个结构体，并将其对齐到16字节边界：

struct alignas(16) MyStruct {
    int x;
	char c;
	double d;
};

如果不使用alignas关键字，则默认情况下结构体将按照系统默认的对齐方式进行内存分配。使用alignas(16)后，编译器会将结构体成员的偏移量调整为16字节的倍数，从而提高程序访问内存时的效率。
除了结构体外，alignas还可以用于变量和数组的声明。例如，以下代码将一个数组对齐到32字节边界：

alignas(32) int arr[100];

需要注意的是，alignas只能应用于POD（Plain Old Data）类型和标量类型，并且不能用于虚拟函数成员。另外，在使用alignas时应谨慎，因为过度的对齐可能会浪费内存空间。

1.14. alignof

C++11中，alignof是一个新的关键字，用于获取类型或变量的对齐方式。它返回一个值，表示该类型或变量在内存中需要按照多少字节的边界进行对齐。VS2015及之后的版本支持此特性。
例如，以下代码使用alignof关键字获取一个结构体的对齐方式：

struct MyStruct {
int x;
char c;
double d;
};

std::cout << alignof(MyStruct); // 输出结果为8（在64位系统上）

在这个示例中，alignof(MyStruct)返回值为8，表示该结构体需要按照8字节的边界进行对齐。这是因为该结构体中包含了一个8字节大小的double类型成员，所以整个结构体需要按照8字节对齐。
和alignas一样，alignof只能应用于POD（Plain Old Data）类型和标量类型，并且不能用于虚拟函数成员。

1.15. Defaulted and deleted functions

引入了两个新的函数声明方式：默认函数（Defaulted functions）和删除函数（Deleted functions）。它们可以让程序员更加方便地控制类的行为和实现。VS2013及之后的版本支持此特性。
默认函数是由关键字default表示的特殊函数，用于在类定义中生成默认的构造函数、拷贝构造函数、移动构造函数、拷贝赋值运算符和移动赋值运算符。例如：

class MyClass {
public:
MyClass() = default; // 默认构造函数
MyClass(const MyClass& other) = default; // 拷贝构造函数
MyClass(MyClass&& other) = default; // 移动构造函数
MyClass& operator=(const MyClass& other) = default; // 拷贝赋值运算符
MyClass& operator=(MyClass&& other) = default; // 移动赋值运算符
};

如果没有显式定义这些函数，编译器会自动为类生成默认版本的这些函数。但是，如果需要显式声明一个函数为默认函数，则需要使用default关键字来表示。
删除函数是由关键字delete表示的特殊函数，用于禁止某些操作或函数调用。例如：

class MyClass {
public:
void doSomething() = delete; // 禁用doSomething函数
};

在这个示例中，doSomething()函数被声明为已删除函数，意味着无法从该类对象调用此函数。
这两种新的函数声明方式可以帮助程序员更好地控制类的行为和实现。默认函数可以简化代码，而删除函数可以避免编写反模式代码，增加代码可读性和可维护性。

1.1.6. Strongly-typed enum

C++11中，引入了强类型枚举（Strongly-typed enum）的新特性。它可以让程序员更加方便地控制枚举类型的作用域和类型安全。VS2012及之后的版本支持此特性。
传统的枚举类型在定义时会将枚举常量放在相同的作用域内，容易出现命名冲突：

enum Color {
Red,
Green,
Blue
};

enum Size {
Small,
Medium,
Large
};

在C++11中，可以使用enum class关键字定义一个强类型枚举类型：

enum class Color {
    Red,
    Green,
    Blue
};

enum class Size {
    Small,
    Medium,
    Large
};

在这个示例中，Color和Size被声明为强类型枚举类型。它们有自己的作用域，并且不能与其他枚举类型进行隐式转换。例如，以下代码是错误的：

Color c = Red; // 错误：无法隐式将Red转换为Color类型

必须显式指定枚举类型，例如：

Color c = Color::Red; // 正确

强类型枚举类型也可以指定底层类型，例如：

enum class MyEnum : unsigned int {
    Value1,
    Value2,
    Value3
};

在这个示例中，MyEnum被指定为unsigned int类型，表示它的底层类型是unsigned int。
强类型枚举类型可以帮助程序员更好地控制枚举类型的作用域和类型安全，避免命名冲突和意外行为。

1.17. Atomic operations

C++11引入了原子操作（Atomic operations）的新特性，它允许程序员在多线程环境中更加安全地进行内存操作。原子操作是指不可被中断的操作，无论何时执行都是整个操作或者不执行。VS2012及之后的版本支持此特性。
C++11提供了一些原子操作的函数，如std::atomic_fetch_add()和std::atomic_store()等。这些函数可以用来对原子类型变量进行读取、写入、比较、交换和算术运算等操作。
以下是一个使用std::atomic_flag的示例代码：

#include 
    #include 
    #include 

    std::atomic_flag lock = ATOMIC_FLAG_INIT;

void func(int id)
{
    while (lock.test_and_set(std::memory_order_acquire))
        ; // 自旋直至获得锁
    std::cout << "Thread " << id << " got the lock." << std::endl;
    // 执行一些操作
    lock.clear(std::memory_order_release); // 释放锁
}

int main()
{
    std::thread t1(func, 1);
    std::thread t2(func, 2);
    t1.join();
    t2.join();
}

在这个示例中，我们使用std::atomic_flag定义了一个原子标志变量lock，并将其初始化为ATOMIC_FLAG_INIT。在两个线程中，我们通过调用test_and_set()函数来获取锁，并通过clear()函数来释放锁。
需要注意的是，原子操作只能应用于原子类型的变量，如std::atomic和std::atomic_flag等。在使用原子操作时，我们还需要指定内存序（Memory order），以确保对共享资源的读写顺序正确。常用的内存序包括std::memory_order_acquire、std::memory_order_release和std::memory_order_seq_cst等。
使用原子操作可以帮助程序员更加安全地进行多线程编程，避免竞态条件和死锁等问题。

1.18. nullptr

在C++11中，nullptr是一个新的关键字，用于表示空指针（Null pointer）。它可以代替以前使用的NULL或0来表示空指针。VS2010及之后的版本支持此特性。
使用nullptr可以避免一些潜在的类型转换问题，因为NULL或0可能会被隐式地转换为布尔类型或整数类型。例如：

void func(int* ptr) { std::cout << "Called func(int*)" << std::endl; }
void func(bool b) { std::cout << "Called func(bool)" << std::endl; }

int main() {
    func(NULL); // 调用func(bool)
    func(0); // 调用func(int*)
}

在这个示例中，由于NULL和0都被转换为了布尔类型false，所以调用了错误的函数。如果使用nullptr来表示空指针，可以避免这种问题。例如：

void func(int* ptr) { std::cout << "Called func(int*)" << std::endl; }
void func(bool b) { std::cout << "Called func(bool)" << std::endl; }

int main() {
    func(nullptr); // 调用func(int*)
    func(0); // 调用func(int*)
}

在这个示例中，由于nullptr是一个特殊的空指针类型，不会被隐式地转换为其他类型，因此可以正确地调用函数。
总的来说，使用nullptr可以使代码更加清晰和类型安全，推荐在C++11中使用nullptr来表示空指针。

1.19. Explicit conversion operators

C++11引入了显式类型转换运算符（Explicit conversion operators）的新特性，允许类定义自己的转换规则，并且可以避免一些潜在的类型转换问题。VS2013及之后的版本支持此特性。
在过去，我们通常通过定义类型转换函数来执行用户定义的类型转换。例如：

class MyClass {
public:
operator int() const { return 0; }
};

int main() {
    MyClass my_obj;
    int foo = my_obj; // 调用operator int()
}

在这个示例中，MyClass定义了一个类型转换函数operator int()，将其转换为整数类型。在使用时，可以直接将MyClass对象赋值给整数类型变量。然而，这种方式可能会导致一些潜在的类型转换问题，因为它允许隐式的类型转换。
C++11中，我们可以使用显式类型转换运算符来替代类型转换函数。例如：

class MyClass {
public:
explicit operator int() const { return 0; }
};

int main() {
    MyClass my_obj;
    int foo = static_cast<int>(my_obj); // 显式调用operator int()
}

在这个示例中，MyClass定义了一个显式类型转换运算符operator int()，通过关键字explicit进行修饰。这意味着类型转换只能以显式的方式进行，不能隐式地进行。在使用时，需要使用static_cast等强制类型转换运算符来显式调用。
使用显式类型转换运算符可以使代码更加明确和类型安全。它可以避免一些潜在的类型转换问题，并且可以使代码更加易于阅读和理解。因此，在C++11中，建议优先使用显式类型转换运算符来定义用户自定义的类型转换。

1.20. ref-qualifiers

在C++11中，引入了成员函数的引用限定符（Ref-qualifiers）的新特性。通过使用左值引用和右值引用限制成员函数的调用方式，进一步提高代码的可读性和类型安全性。VS2015及之后的版本支持此特性。
引用限定符可以是&或&&，分别表示左值引用和右值引用。例如：

class MyClass {
public:
void func() & { std::cout << "Called func() on lvalue" << std::endl; }
void func() && { std::cout << "Called func() on rvalue" << std::endl; }
};

int main() {
    MyClass my_obj;
    my_obj.func(); // 调用func() &
    std::move(my_obj).func(); // 调用func() &&
}

在这个示例中，MyClass定义了两个成员函数func()，分别带有左值引用限定符&和右值引用限定符&&。当通过左值或右值调用时，会自动调用相应限定符的成员函数。
需要注意的是，如果一个成员函数没有引用限定符，则可以被任何类型的对象调用。如果同时定义了左值引用限定符和右值引用限定符，则会导致编译错误。
引用限定符可以使代码更加清晰和类型安全，因为它可以限制某些函数只能被左值或右值调用。这可以避免一些潜在的错误，并且可以使代码更加易于理解和维护。

1.21. Unicode string literals

在C++11中，引入了Unicode字符串字面量（Unicode string literals）的新特性。以前，我们通常使用ASCII字符串字面量来表示字符串，但是对于一些国际化的应用程序来说，它们可能需要支持Unicode字符集。VS2015及之后的版本支持此特性。
Unicode字符串字面量可以通过在字符串前添加前缀u8、u、U或L来表示不同的宽度。例如：

std::cout << u8"Hello, world! 你好，世界！" << std::endl; // UTF-8编码
std::wcout << L"Hello, world! 你好，世界！" << std::endl; // 宽字符串
std::cout << u"Hello, world! \u4F60\u597D\uFF0C\u4E16\u754C\uFF01" << std::endl; // UTF-16编码
std::cout << U"Hello, world! \U00002014\u4E16\u754C\uFF01" << std::endl; // UTF-32编码

在这个示例中，我们分别使用了UTF-8、宽字符串、UTF-16和UTF-32编码的Unicode字符串字面量。其中，前缀u8表示UTF-8编码，前缀L表示宽字符串，前缀u表示UTF-16编码，前缀U表示UTF-32编码。在输出时，可以使用std::cout或std::wcout来输出不同编码格式的字符串。
使用Unicode字符串字面量可以使代码更加清晰和易于阅读，特别是在处理国际化的应用程序时。它可以避免一些字符集转换的问题，并且可以使代码更加易于维护和扩展。

1.22. Raw string literals

在C++11中，引入了原始字符串字面量（Raw string literals）的新特性。相对于普通的字符串字面量，原始字符串字面量可以避免一些转义字符的问题，并且可以直接表示包含换行符和空格符的多行字符串。VS2013及之后的版本支持此特性。
原始字符串字面量使用双引号和括号来表示，其中，括号内可以添加一个可选的标识符，用于指定字符串字面量的类型。例如：

std::cout << R"(Hello, world!\n)" << std::endl; // 输出"Hello, world!\n"
std::cout << R"***("Hello, world!
    This is a multi-line
    raw string.")***" << std::endl; // 输出包含换行符和空格符的多行字符串

在这个示例中，我们分别使用了带有和不带有标识符的原始字符串字面量。注意，原始字符串字面量的内容不会被解释为转义序列，因此，如果需要表示反斜杠字符、双引号字符或换行符等特殊字符，可以直接写入代码中。
原始字符串字面量可以使代码更加清晰和易于阅读，特别是在处理多行字符串和需要包含大量转义字符的情况下。它可以避免一些字符集转换和编码问题，并且可以使代码更加易于维护和扩展。

1.23. Inline namespaces

在C++11中，引入了内联命名空间（Inline namespaces）的新特性。内联命名空间可以使命名空间的嵌套层次更加简单和清晰，并且可以提供一些额外的灵活性。VS2015及之后的版本支持此特性。
当我们在一个命名空间中定义另一个命名空间时，可以使用inline关键字将其声明为内联命名空间。例如：

namespace A {
inline namespace B {
void func() { std::cout << "Called func() in A::B" << std::endl; }
}
}

int main() {
    A::func(); // 调用A::B::func()
}

在这个示例中，我们在命名空间A中定义了一个内联命名空间B，并在其中定义了函数func()。注意，由于B是内联命名空间，因此，在使用func()时可以直接在命名空间A中调用，而不需要指定B。
使用内联命名空间可以使命名空间的嵌套层次更加简单和清晰，特别是在需要重新组织命名空间结构时。它可以提供一些额外的灵活性，比如可以在不影响其他代码的情况下添加或删除一些命名空间层次。

1.24. Inheriting constructors

在C++11中，引入了继承构造函数（Inheriting constructors）的新特性。通过使用继承构造函数，可以避免在派生类中重新定义和实现与基类相同的构造函数，从而简化代码结构和提高代码重用性。VS2015及之后的版本支持此特性。
通过使用关键字using和基类的构造函数名，可以将基类的构造函数“继承”到派生类中。例如：

class Base {
public:
Base(int v) : value(v) {}
private:
int value;
};

class Derived : public Base {
public:
using Base::Base;
void func() { std::cout << "value = " << value << std::endl; }
};

int main() {
    Derived obj(123);
    obj.func(); // 输出"value = 123"
}

在这个示例中，我们定义了一个基类Base和一个派生类Derived，并使用using Base::Base来继承基类的构造函数。注意，由于派生类中没有显式定义构造函数，因此编译器会自动继承基类的构造函数。在使用时，可以像使用基类构造函数一样来创建派生类对象。
使用继承构造函数可以简化代码结构和提高代码重用性，特别是在需要在派生类中实现与基类相同的构造函数时。它可以避免代码重复和错误，同时使代码更加易于维护和扩展。

1.25. Trailing function return types

在C++11中，引入了一种新的函数声明语法——尾置返回类型（Trailing function return types）。使用尾置返回类型可以将函数返回值的类型放在函数参数表达式之后，从而使代码更加清晰和易于阅读。VS2010及之后的版本支持此特性。尾置返回类型的代码可读性不一定好，谨慎使用。
通常情况下，在定义函数时，返回值类型是紧跟在函数名之后的。例如：

int add(int x, int y) {
    return x + y;
}

在这个示例中，int是add()函数的返回值类型，紧跟在函数名之后。
使用尾置返回类型的语法可以将返回值类型移动到函数参数列表之后，并使用关键字auto来指示返回值类型。例如：

auto add(int x, int y) -> int {
    return x + y;
}

在这个示例中，我们使用尾置返回类型的语法来定义add()函数，并将返回值类型int放在箭头符号->之后。由于我们已经指定了返回值类型为int，因此可以省略函数名前面的返回值类型。
使用尾置返回类型可以使函数声明更加清晰和直观，特别是在函数返回值类型比较复杂或难以理解时。它还可以使代码更加灵活，因为可以在函数参数列表中使用表达式来计算返回值类型。

1.26. Unrestricted Union

在C++11标准中，提供了一种新的联合（Union）类型——无限制联合（Unrestricted Union）。与传统联合不同，无限制联合允许将非POD（Plain Old Data）类型作为联合的成员。此功能谨慎使用。VS2015及之后的版本支持此特性。
在传统联合中，由于不同成员共享内存，因此只能使用POD类型作为成员。而在无限制联合中，可以使用任何类型作为联合的成员，并且可以同时访问不同成员的值。例如：

union MyUnion {
int i;
double d;
std::string s;
};

在这个示例中，我们定义了一个名为MyUnion的无限制联合，其中包含了一个int类型成员i、一个double类型成员d，以及一个std::string类型成员s。由于这是一个无限制联合，因此可以使用任何类型作为成员，甚至包括非POD类型。
需要注意的是，由于不同成员共享内存，因此在使用无限制联合时，需要非常小心。如果在某个成员中存储了一个值，然后在另一个成员中读取该值，可能会导致未定义行为。因此，在使用无限制联合时，应该遵循一些规则和最佳实践，以确保程序的正确性和稳定性。
总的来说，无限制联合是C++11中一个很有用的特性，它可以使代码更加灵活和易于扩展。但是，由于使用无限制联合需要一些额外的注意事项，因此在实际应用中需要慎重考虑。

1.27. Variadic templates

C++11引入了一种新的模板特性——可变参数模板（Variadic templates），允许使用可变数量的模板参数来定义函数或类模板。VS2013及之后的版本支持此特性。
使用可变参数模板，可以方便地处理不同数量和类型的参数。它在实现一些通用算法时非常有用，例如打印任意数量的变量。下面是一个简单的例子：

#include 

    // 递归函数模板，用于打印任意数量的变量
    void print() {
        std::cout << std::endl;
    }

template<typename T, typename... Args>
void print(T firstArg, Args... args) {
    std::cout << firstArg << " ";
    print(args...);
}

int main() {
    int i = 10;
    double d = 3.14;
    std::string s = "hello";

    // 打印三个变量
    print(i, d, s);

    return 0;
}

在这个示例中，我们定义了一个名为print的递归函数模板，用于打印任意数量的变量。在print函数的第一个重载中，我们只打印一个换行符，并将其作为递归终止条件。在第二个重载中，我们打印第一个参数，并使用可变参数模板来递归处理后续的参数。
需要注意的是，在可变参数模板中，参数包必须至少包含一个元素。因此，在定义可变参数模板时，需要提供一个非可变参数模板的基准情况。
总之，可变参数模板是C++11中一个非常有用的特性，可以方便地处理不同数量和类型的参数，并使代码更加通用和灵活。

1.28. Expression SFINAE

在C++11中，引入了一种新的SFINAE（Substitution Failure Is Not An Error）技术——表达式SFINAE（Expression SFINAE），用于在编译时根据类型推导和表达式匹配来进行模板参数推断和选择。VS2017及之后的版本支持此特性。
通过使用表达式SFINAE，可以使代码更加灵活和通用。例如，在模板函数中使用std::enable_if结合表达式SFINAE，可以实现对不同类型的局部特化。下面是一个简单的例子：

#include 
#include 

template<typename T>
typename std::enable_if<!std::is_array<T>::value, void>::type
print(T t) {
    std::cout << t << std::endl;
}

template<typename T>
typename std::enable_if<std::is_array<T>::value, void>::type
print(T t) {
    for (auto elem : t) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;
}

int main() {
    int i = 10;
    int arr[] = {1, 2, 3};

    // 调用第一个print函数，打印一个整数
    print(i);

    // 调用第二个print函数，打印一个数组
    print(arr);

    return 0;
}

在这个示例中，我们定义了两个重载的print函数模板，分别用于打印非数组类型和数组类型。在每个函数模板中，我们使用std::enable_if结合表达式SFINAE来限制函数模板的使用条件。
需要注意的是，在表达式SFINAE中，使用typename std::enable_if来定义子类型，通过指定value成员来进行选择。在编译时，如果表达式无法匹配，则会导致模板参数推断失败，并尝试选择另一个模板函数。
总之，表达式SFINAE是C++11中非常有用的技术，它可以实现对不同类型的局部特化，使代码更加灵活和通用。但是，在使用表达式SFINAE时，需要小心避免过度使用，以免降低代码的可读性和可维护性。

1.29. Local and unnamed types as template parameters

在C++11中，允许将本地和匿名类型用作模板参数。这意味着，可以在函数内部定义类型并将其用作模板参数，从而使代码更加灵活和通用。VS2010及之后的版本支持此特性。
例如，使用本地和匿名类型作为模板参数，可以实现对不同类型的局部特化，避免了使用全局或命名类型时可能引起的命名冲突和可移植性问题。下面是一个简单的例子：

#include 

template<typename T>
void print(T t) {
    std::cout << t << std::endl;
}

int main() {
    struct { int x, y; } point = { 10, 20 };
    print(point);

    return 0;
}

在这个示例中，我们定义了一个名为point的本地结构体，并将其作为模板参数传递给print函数。由于point是一个本地类型，没有名称，因此我们需要使用struct { int x, y; }来定义它。
需要注意的是，在使用本地和匿名类型作为模板参数时，需要小心处理与模板推断相关的限制。如果使用了太多的模板参数，可能会导致编译错误。
总之，C++11中允许使用本地和匿名类型作为模板参数，使代码更加灵活和通用。但是，在使用本地和匿名类型时，需要考虑一些额外的限制和最佳实践，以确保程序的正确性和稳定性。

1.30. Thread-local storage

在C++11标准中，引入了一种新的存储类别——线程局部存储（Thread-local storage），用于定义仅在当前线程中可见的变量。VS2015及之后的版本支持此特性。
使用线程局部存储，可以使多线程程序更加安全和稳定。例如，在一个多线程程序中，可以使用线程局部存储来保存每个线程的状态信息，并避免不同线程之间的干扰和竞争。下面是一个简单的例子：

#include 
#include 
#include 

// 线程局部存储
thread_local int counter = 0;

void increment() {
    counter++;
    std::cout << "Counter value: " << counter << std::endl;
}

int main() {
    std::vector<std::thread> threads;

    // 创建10个线程，并执行increment函数
    for (int i = 0; i < 10; i++) {
        threads.push_back(std::thread(increment));
    }

    // 等待所有线程结束
    for (auto& t : threads) {
        t.join();
    }

    return 0;
}

在这个示例中，我们定义了一个名为counter的线程局部变量，并将其初始化为0。然后，我们创建了10个线程，并在每个线程中执行increment函数。在increment函数中，我们递增计数器并打印其值。由于counter是线程局部变量，因此每个线程都有自己的副本，并且可以独立地递增和打印其值。
需要注意的是，在使用线程局部存储时，需要小心处理变量的生命周期和初始化。在多线程程序中，不同线程的执行顺序和时间可能是随机的，因此需要确保每个线程都能正确地初始化和使用线程局部变量。
总之，C++11中引入的线程局部存储是一种非常有用的特性，可以使多线程程序更加安全和稳定。但是，在使用线程局部存储时，需要考虑一些额外的限制和最佳实践，以确保程序的正确性和稳定性。

1.31. Dynamic initialization and destruction with concurrency

在C++11标准中，引入了一种新的动态初始化和销毁机制，它可以在多线程环境下安全地进行对象的初始化和销毁。VS2015及之后的版本支持此特性。
使用这种机制，可以保证全局和静态对象的初始化顺序，并避免了在多线程程序中可能出现的竞争和死锁等问题。同时，也可以确保在程序结束时，所有全局和静态对象都得到正确的销毁。VS2015及之后的版本支持此特性。
这种机制是通过使用std::call_once函数和std::once_flag类型来实现的。std::call_once函数接受一个函数指针和一个std::once_flag对象作为参数，在第一次调用时执行函数并标记std::once_flag对象，以后的调用将不再执行该函数。因此，可以使用std::call_once来保证全局和静态对象的初始化只会发生一次。
下面是一个简单的例子：

#include 
#include 

// 全局变量
int global_value = 0;

// 函数对象
struct init_global {
void operator()() const {
    std::cout << "Initializing global value..." << std::endl;
    // 进行一些初始化操作
    global_value = 42;
}
};

// 调用std::call_once初始化全局变量
void initialize_global() {
    static std::once_flag flag;
    std::call_once(flag, init_global());
}

int main() {
    // 在多个线程中调用initialize_global函数
    std::thread t1(initialize_global);
    std::thread t2(initialize_global);

    // 等待所有线程结束
    t1.join();
    t2.join();

    // 打印全局变量的值
    std::cout << "Global value: " << global_value << std::endl;

    return 0;
}

在这个示例中，我们定义了一个名为global_value的全局变量，并使用函数对象init_global来初始化它。然后，我们定义了一个名为initialize_global的函数，在其中使用std::call_once和std::once_flag来保证全局变量只会被初始化一次。最后，在多个线程中调用initialize_global函数，并打印全局变量的值。
需要注意的是，在使用动态初始化和销毁机制时，需要小心处理初始化和销毁的顺序，以避免可能出现的问题。同时，在多线程程序中，也需要注意使用锁等机制来保护共享资源的访问。
总之，C++11中引入的动态初始化和销毁机制可以使多线程程序更加安全和稳定，但是需要小心处理初始化和销毁的顺序，并遵循一些最佳实践来保护共享资源的访问。

1.32. Initializer lists

C++11引入了初始化列表，允许使用用大括号包含的值列表对对象进行初始化。当定义数组、向量和其他可以容纳多个值的类型时，此功能非常有用。VS2013及之后的版本支持此特性。例如：

// 初始化一个数组
int arr[] = {1, 2, 3, 4, 5};

// 初始化一个向量
std::vector<int> vec = {6, 7, 8, 9, 10};

初始化列表也可以用作函数参数以提供多个值。
当我们使用初始化列表时，我们可以提供一个或多个值，它们将按照在大括号中出现的顺序进行初始化。这意味着我们可以轻松地定义和初始化数组、向量和其他容器。
例如，假设我们有一个名为"Person"的结构体：

struct Person {
std::string name;
int age;
};

我们可以使用初始化列表来创建并初始化一个名为"person1"的"Person"对象，如下所示：

c++复制代码Person person1 = {"Alice", 25};

这个语法非常简洁明了，同时也很容易理解。我们甚至可以使用初始化列表来初始化包含其他对象的对象，例如：

std::vector<Person> people = {{"Alice", 25}, {"Bob", 30}, {"Charlie", 35}};

这里，我们使用初始化列表来创建一个名为"people"的向量，其中包含三个不同的"Person"对象。
初始化列表还可以用作函数参数，允许我们向函数传递多个值。例如：

void print_values(std::initializer_list<int> values) {
    for (auto value : values) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
}

int main() {
    print_values({1, 2, 3, 4, 5});
    return 0;
}

在这个例子中，我们定义了一个名为"print_values"的函数，该函数接受一个整数初始化列表，并打印每个值。然后，在主函数中，我们使用初始化列表来调用该函数，并传递5个整数值。
总之，初始化列表是C++11引入的一项非常有用的功能，它使我们能够更轻松地定义和初始化数组、向量和其他容器，并可以作为函数参数使用。

1.33. Non-static data member initializers

C++11引入了非静态数据成员初始化器，允许在类定义中提供默认的数据成员值。这样做可以使我们更容易地初始化和修改类的数据成员，并提高代码的可读性。C++支持多种方式初始化，同一个文件中的初始化应该保持一致性。VS2013及之后的版本支持此特性。
例如，假设我们有一个名为"Person"的类：

class Person {
public:
std::string name;
int age;
};

如果我们希望每个"Person"对象都具有默认的姓名和年龄值，我们可以使用非静态数据成员初始化器来实现：

class Person {
public:
std::string name = "Unknown";
int age = 0;
};

现在，每当我们创建一个新的"Person"对象时，它们的"name"和"age"数据成员将默认设置为"Unknown"和0。
非静态数据成员初始化器也可以用于其他类型的数据成员，包括数组和向量。例如：

class MyClass {
public:
int arr[3] = {1, 2, 3};
std::vector<int> vec = {4, 5, 6};
};

这里，我们定义了一个名为"MyClass"的类，该类具有一个名为"arr"的整数数组和一个名为"vec"的整数向量，它们分别默认初始化为{1, 2, 3}和{4, 5, 6}。
总之，C++11的非静态数据成员初始化器提供了一种方便的方法来初始化类的数据成员，可以使我们的代码更容易理解和维护。

1.34. Attributes

C++11引入了属性（Attributes），它们是一种标记语法，可用于指定编译器的特定行为。属性可以应用于许多程序实体，例如函数、类和变量。VS2015及之后的版本支持此特性。
一个常见的属性是[[deprecated]]，它用于标记已被弃用的函数、类和变量。例如：

[[deprecated("Use new_function instead")]]
void old_function() {
    // ...
}

在这个例子中，我们使用[[deprecated]]属性将"old_function"函数标记为已弃用，并提供一个自定义的警告消息。
另一个有用的属性是[[nodiscard]]，它可用于指示函数的返回值应该被检查，以避免潜在的错误或漏洞。例如：

[[nodiscard]] int get_value() {
    // ...
}

在这里，我们使用[[nodiscard]]属性来标记"get_value"函数，表示它的返回值应该被检查。返回值必须赋值给某变量或使用static_case来修饰。
其他C++11属性包括[[carries_dependency]]、[[noreturn]]、[[alignas]]、[[alignof]]等。属性还可以与预处理指令结合使用，如：

#if defined(__has_cpp_attribute) && __has_cpp_attribute(nodiscard)
#define NODISCARD [[nodiscard]]
#else
#define NODISCARD
#endif

这里，我们使用__has_cpp_attribute预处理指令来检查是否支持[[nodiscard]]属性，并根据需要定义一个NODISCARD宏。
总之，C++11引入的属性提供了一种方便的方法来添加元数据和指示编译器的行为，可以使我们的代码更清晰、更可读，并避免潜在的错误或漏洞。

1.35. Forward (opaque) enum declarations

C++11引入了前向（不透明）枚举声明，允许我们在不定义枚举值的情况下声明枚举类型。这使得代码更清晰、更易读，并可以避免命名空间污染的问题。VS2012及之后的版本支持此特性。
具体来说，前向枚举声明使用enum class关键字，后跟枚举名称和一个分号，如下所示：

enum class Color;

现在，我们可以在代码中使用"Color"枚举类型，但不能直接使用任何枚举值。例如：

enum class Color;

void set_color(Color color) {
    // ...
}

int main() {
    set_color(Color::red);  // Error: 'Color' is an incomplete type
    return 0;
}

在这个例子中，我们定义了一个名为"Color"的枚举类型，然后定义了一个名为"set_color"的函数，该函数接受一个"Color"类型的参数。然而，在主函数中，我们试图使用"Color::red"枚举值调用"set_color"函数，但编译器会提示错误，因为"Color"类型是不完整的。
相反，我们需要在定义枚举值之前先定义枚举类型，或者使用强制转换将枚举值转换为整数类型。例如：

enum class Color {
red,
green,
blue
};

void set_color(Color color) {
    // ...
}

int main() {
    set_color(static_cast<Color>(0)); // OK: Explicit conversion from integer to enumeration
    return 0;
}

在这个例子中，我们首先定义了一个名为"Color"的枚举类型，并指定了三个枚举值。然后，在主函数中，我们使用static_cast来将整数值0转换为"Color"类型的枚举值，从而成功调用了"set_color"函数。
总之，前向枚举声明是C++11引入的一项非常有用的功能，可以使代码更清晰、更易读，并避免命名空间污染的问题。

1.36. User-defined literals

C++11引入了用户自定义字面量（User-defined literals），它允许我们定义自己的字面量后缀，以便将特定类型的值转换为其对应的类型，并使代码更加清晰和易读。VS2015及之后的版本支持此特性。
具体来说，用户自定义字面量使用以下语法：

<literal>operator "" <suffix>(<arguments>)

其中，是一个整数字面量、浮点数字面量、字符数字面量、字符串字面量或布尔字面量；是我们定义的后缀标识符，表示我们要将字面量转换为的类型；是可选的参数列表，用于指定在转换期间使用的其他信息。
例如，假设我们想要定义一个名为"operator “”_km"的用户自定义字面量，用于将公里数转换为米数（1 km = 1000 m）。我们可以这样实现：

constexpr long double operator "" _km(long double kilometers) {
    return kilometers * 1000;
}

现在，我们可以使用"_km"后缀来将公里数转换为米数，例如：

auto distance = 3.5_km;
std::cout << distance << " meters" << std::endl; // Output: 3500 meters

在这个例子中，我们使用"_km"后缀来将3.5公里转换为米数，并将结果存储在名为"distance"的变量中。然后，我们打印出"distance"的值，得到输出"3500 meters"。
用户自定义字面量还可以用于其他类型的值，如时间、角度、货币等。例如，我们可以定义一个名为"operator “”_deg"的用户自定义字面量，将角度值转换为弧度：

constexpr long double operator "" _deg(long double degrees) {
    return degrees * 3.14159265358979323846 / 180;
}

现在，我们可以使用"_deg"后缀来将角度值转换为弧度值，例如：

auto angle = 45.0_deg;
std::cout << angle << " radians" << std::endl; // Output: 0.785398 radians

在这个例子中，我们使用"_deg"后缀来将45度转换为弧度，并将结果存储在名为"angle"的变量中。然后，我们打印出"angle"的值，得到输出"0.785398 radians"。
总之，用户自定义字面量是C++11引入的一项非常有用的功能，可以使代码更加清晰和易读，并允许我们定义自己的字面量后缀来转换特定类型的值。

1.37. Rvalue references

C++11引入了右值引用（Rvalue references），它们是一种新的引用类型，用于支持移动语义（Move Semantics）和完美转发（Perfect Forwarding）。通过使用右值引用，我们可以轻松地实现高效的资源管理，并避免不必要的复制和分配操作。VS2010及之后的版本支持此特性。
具体来说，右值引用使用&&符号表示，例如：

int&& rvalue_ref = 42;

在这个例子中，我们定义了一个名为"rvalue_ref"的右值引用，它绑定到一个临时整数值42。
右值引用最常见的用途之一是移动语义，在STL容器和智能指针等类中非常有用。例如，假设我们有一个名为"MyClass"的类，它有一个包含大量数据的成员变量：

class MyClass {
public:
// ...

private:
std::vector<int> data_;
};

如果我们创建一个"MyClass"对象，并将其复制到另一个对象中，会发生什么？每个数据成员都会被复制，包括矢量数据。这可能会导致性能问题，尤其是对于大型数据结构。
然而，如果我们使用移动语义，就可以避免这个问题。移动语义允许我们将一个对象的内容移动到另一个对象中，而不是进行复制。这使得对象的复制效率更高，并减少了内存分配和释放的次数。
为了支持移动语义，我们需要为"MyClass"类定义一个移动构造函数和一个移动赋值运算符，例如：

class MyClass {
public:
// ...

// Move constructor
MyClass(MyClass&& other) noexcept : data_(std::move(other.data_)) {}

// Move assignment operator
MyClass& operator=(MyClass&& other) noexcept {
    if (this != &other) {
        data_ = std::move(other.data_);
    }
    return *this;
}

private:
std::vector<int> data_;
};

在这个例子中，我们为"MyClass"类定义了一个移动构造函数和一个移动赋值运算符。它们使用std::move函数将"data_"vector数据从一个对象移动到另一个对象，并确保避免资源泄漏。
总之，C++11的右值引用提供了一种非常有用的功能，可以支持移动语义和完美转发，使代码更高效、更优雅，并减少资源分配和释放的次数。

1.38. Lambda expressions

C++11引入了Lambda表达式，它是一种轻量级的匿名函数，允许我们在需要时定义一个简单的函数对象，而不必编写完整的函数定义。VS2010及之后的版本支持此特性。
Lambda表达式使用以下语法：

[capture_list] (parameter_list) -> return_type {body}

其中，[capture_list]是捕获列表，用于指定Lambda表达式中使用的外部变量；(parameter_list)是参数列表，用于指定Lambda表达式接受的参数；-> return_type是返回类型，用于指定Lambda表达式的返回类型；{body}是函数体，包含Lambda表达式要执行的代码块。
例如，假设我们有一个名为"numbers"的矢量，包含几个整数值。如果我们想要计算这些数字的平均值，可以使用Lambda表达式来实现：

#include 
#include 

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    auto average = std::accumulate(numbers.begin(), numbers.end(), 0.0,
    [](double total, int number) { 
        return total + static_cast<double>(number) / numbers.size(); 
    });

    return 0;
}

在这个例子中，我们使用std::accumulate算法来计算"numbers"矢量中元素的总和，并将其除以矢量大小来得到平均值。我们使用Lambda表达式作为std::accumulate的第四个参数，指定如何累加每个数字。
Lambda表达式中的捕获列表可以指定要在Lambda表达式中使用的外部变量，例如：

int x = 10;

auto lambda = [x](int y) {
    return x + y;
};

int result = my_lambda(5); // result is 15

在这个例子中，我们定义了一个名为"lambda"的Lambda表达式，它捕获了"x"变量，并将其用于计算输入参数"y"的总和。
总之，Lambda表达式是C++11引入的一项非常有用的功能，可以使代码更简洁、更可读，并允许我们轻松地定义一个匿名函数对象。

1.39. Range-for loop

C++11引入了范围for循环（Range-for loop），它是一种轻便的语法，用于遍历和操作容器中的元素。VS2012及之后的版本支持此特性。
范围for循环使用以下语法：

for (element : container) {
    // do something with element
    }

其中，"container"是需要遍历的容器，例如数组、矢量、列表、集合或映射。在每次迭代中，当前元素会被自动绑定到名为"element"的变量，并执行循环体中的操作。
例如，假设我们有一个名为"numbers"的矢量，包含几个整数值。如果我们想要打印每个数字，可以使用范围for循环来实现：

#include 
#include 

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    for (int number : numbers) {
        std::cout << number << " ";
    }

    return 0;
}

在这个例子中，我们使用范围for循环遍历"numbers"矢量中的每个元素。在每次迭代中，当前元素会被自动绑定到名为"number"的变量，并将其打印到标准输出流中。
范围for循环也可以用于其他类型的容器，例如映射。例如，假设我们有一个名为"months"的映射，将每个月份的名称映射到相应的天数。如果我们想要打印每个月份和其天数，可以使用范围for循环来实现：

#include 
    #include 

    int main() {
        std::map<std::string, int> months = {
        {"January", 31},
        {"February", 28},
        {"March", 31},
        // ...
    };

        for (auto& [month, days] : months) {
            std::cout << month << " has " << days << " days." << std::endl;
        }

        return 0;
    }

在这个例子中，我们使用范围for循环遍历"months"映射中的每个键值对。在每次迭代中，当前键和值会被自动绑定到名为"month"和"days"的变量，并将它们打印到标准输出流中。
总之，范围for循环是C++11引入的一项非常有用的功能，可以使代码更加简单、易读，并提高容器操作的效率。

1.40. noexcept

C++11引入了noexcept关键字，它用于指示函数是否可能引发异常。在C++中，异常处理是一项非常重要的任务，可以使代码更加健壮、可靠，并提高程序的可维护性。VS2015及之后的版本支持此特性。
noexcept关键字使用以下语法：

void my_function() noexcept {
    // function body
}

其中，"my_function()"是需要指示是否可能引发异常的函数。如果函数不会引发异常，则可以将其标记为noexcept。这有助于编译器优化代码，提高程序的性能和效率。
例如，假设我们有一个名为"my_function"的函数，它不会引发异常。我们可以将它标记为noexcept，以告知编译器该函数不会引发异常：

void my_function() noexcept {
    // function body
}

然后，编译器可以根据noexcept关键字，生成更快、更高效的代码。
另外，noexcept还可以用于指示移动构造函数和移动赋值运算符是否可以抛出异常。如果移动操作被标记为noexcept，则STL容器和智能指针等类可以在内部进行优化，提高操作的速度和效率。
例如，假设我们有一个名为"MyClass"的类，并为其定义了一个移动构造函数和一个移动赋值运算符。如果这些移动操作不会抛出异常，则可以将它们标记为noexcept：

class MyClass {
public:
// ...

// Move constructor
MyClass(MyClass&& other) noexcept : data_(std::move(other.data_)) {}

// Move assignment operator
MyClass& operator=(MyClass&& other) noexcept {
    if (this != &other) {
        data_ = std::move(other.data_);
    }
    return *this;
}

private:
std::vector<int> data_;
};

在这个例子中，我们为"MyClass"类定义了一个移动构造函数和一个移动赋值运算符，并将它们标记为noexcept。这有助于STL容器和智能指针等类进行内部优化，并提高操作的速度和效率。
总之，noexcept是C++11引入的一项非常有用的功能，可以指示函数是否可能引发异常，并提高程序的性能和效率。

1.41. Defaulted move special member functions

在C++11中，我们可以使用"= default"语法来定义移动特殊成员函数的默认实现，包括移动构造函数和移动赋值运算符。这样可以避免大量的样板代码，同时确保类的正确性和可移植性。VS2015及之后的版本支持此特性。
例如，假设我们有一个名为"MyClass"的类，它包含一个std::vector成员变量，并为其定义了一个移动构造函数和一个移动赋值运算符，我们可以使用"= default"语法来定义它们的默认实现：

class MyClass {
public:
// Default constructor
MyClass() = default;

// Move constructor
MyClass(MyClass&& other) noexcept = default;

// Move assignment operator
MyClass& operator=(MyClass&& other) noexcept = default;

private:
std::vector<int> data_;
};

在上述示例中，我们为MyClass类的移动构造函数和移动赋值运算符添加了"default"关键字，告诉编译器我们希望它们的默认实现。这将生成适当的代码来移动数据成员，并确保对象状态的正确转移。
如果我们没有提供自定义的移动构造函数或移动赋值运算符，并且我们想要使用编译器提供的默认实现，则可以省略移动操作的声明，从而使用编译器提供的缺省实现：

class MyClass {
public:
// Default constructor

// No need to declare move constructor or move assignment operator
// because the compiler will provide them automatically.

private:
std::vector<int> data_;
};

在这个例子中，我们没有提供自定义的移动构造函数或移动赋值运算符，并省略了它们的声明，因此编译器将为我们提供适当的默认实现。
总之，默认的移动特殊成员函数是C++11引入的一项非常有用的功能，使得我们可以轻松地避免样板代码，并确保类的正确性和可移植性。
在C++11中，我们可以使用"= default"语法来定义移动特殊成员函数的默认实现，也可以不声明这些函数从而使用编译器提供默认的实现。这两种方式有以下区别：

1. "= default"语法明确指定了移动特殊成员函数的意图，使得代码更加清晰易懂。如果你在类定义中看到了这样的语义，就能够立即知道该类具有移动构造函数和移动赋值运算符，并且它们是默认实现的。
2. 如果我们使用"= default"语法定义移动特殊成员函数的默认实现，则可以为其添加其他限制条件，例如"noexcept"关键字。这有助于确保代码的正确性和可移植性。
3. 如果我们不声明移动特殊成员函数并让编译器提供默认实现，则编译器可能会生成一个未定义行为或错误的实现。这是因为编译器默认实现的质量取决于类成员的类型和实现细节等因素。如果我们需要确保代码的正确性和可移植性，则最好使用"= default"语法来定义移动特殊成员函数的默认实现。

总之，使用"= default"语法来定义移动特殊成员函数的默认实现可以使代码更加清晰易懂，并且允许我们添加其他限制条件以确保代码的正确性和可移植性。如果我们省略移动特殊成员函数的声明，则需要确保编译器提供的默认实现是正确且可移植的。

1.42. override and final

在C++11中，我们可以使用"override"和"final"关键字来改进类的继承和多态性。VS2012及之后的版本支持此特性。

1. "override"关键字：用于表示派生类中的虚函数重写了基类中的同名虚函数。它可以帮助编译器检查函数签名是否匹配，以避免由于不小心改变函数签名而导致的错误。

例如，假设我们有一个名为"Base"的基类和一个名为"Derived"的派生类，并在两个类中都定义了一个名为"foo()"的虚函数。如果我们希望在派生类中重写基类的"foo()"函数，则可以使用"override"关键字：

class Base {
public:
virtual void foo();
};

class Derived : public Base {
public:
void foo() override;
};

在上述示例中，我们在派生类中重写了基类的虚函数，并使用"override"关键字指示这是对基类函数的覆盖。这有助于确保函数签名匹配并减少错误。

2. "final"关键字：用于防止派生类进一步重写虚函数或继续派生。它可以帮助防止错误，并将类的继承结构固定在某个级别上。

例如，假设我们有一个名为"Base"的基类和一个名为"Derived"的派生类，并在基类中定义了一个名为"foo()"的虚函数。如果我们希望防止派生类进一步重写该函数，则可以使用"final"关键字：

class Base {
public:
virtual void foo() final;
};

class Derived : public Base {
public:
// Compile-time error: cannot override "foo()" because it is final in "Base"
void foo() override; 
};

在上述示例中，我们在基类中定义了一个名为"foo()“的虚函数，并将其标记为"final”。这意味着派生类不能进一步重写该函数。因此，在派生类中重写"foo()"将导致编译时错误。
总之，"override"和"final"是C++11引入的两个非常有用的功能，它们可以帮助我们改进类的继承和多态性，并减少由于不小心改变函数签名而导致的错误。

1.43. decltype

C++11引入了decltype关键字，用于检查表达式的类型而不实际计算该表达式。这使得代码更加灵活并提高了模板编程的能力。
decltype关键字使用以下语法：

decltype(expression) var_name;

其中，"expression"是需要检查类型的表达式，例如变量、函数调用或算术运算等。在这个语法中，编译器会解析"expression"的类型，并将其赋值给"var_name"变量。
例如，假设我们有一个名为"my_var"的整型变量，我们可以使用decltype关键字来检查它的类型并声明一个相同类型的新变量：

int my_var = 42;

decltype(my_var) new_var; // new_var is an int

在上述示例中，我们使用decltype关键字检查"my_var"的类型，并将其赋值给"new_var"变量。由于"my_var"是一个整型变量，因此"new_var"也被推断为整型。
除了变量，我们还可以使用decltype关键字检查函数调用和表达式中的类型。例如，假设我们有一个名为"add"的函数，它接受两个整数并返回它们的和。我们可以使用decltype关键字来检查函数调用的返回类型：

int add(int a, int b) {
    return a + b;
}

decltype(add(1, 2)) sum; // sum is an int

在上述示例中，我们使用decltype关键字检查"add(1, 2)"的返回类型，并将其赋值给"sum"变量。由于"add(1, 2)"返回一个整型，因此"sum"也被推断为整型。
在C++11中，我们可以使用auto关键字来进行返回值类型推导，从而使函数的返回类型更加灵活和通用。
例如，假设我们有一个名为"add"的函数模板，它接受两个参数并返回它们的和。在C++11中，我们可以使用auto关键字作为函数返回类型，并让编译器根据返回表达式自动推导返回类型：

template<typename T>
auto add(T a, T b) -> decltype(a + b) {
    return a + b;
}

在上述示例中，我们使用auto关键字作为函数返回类型，并使用decltype关键字检查a+b的类型以进行返回值类型推导。由于a和b的类型相同，因此它们的求和结果也应该具有相同的类型。这使得编译器能够自动推导返回类型，并避免了显式指定返回类型的繁琐。
需要注意的是，当auto关键字用于函数返回类型时，我们需要使用函数后置返回类型语法（trailing return type syntax）来指定返回类型。这是因为auto关键字不能单独用于函数返回类型。
总之，auto关键字可以用于函数返回类型推导，从而使代码更加简洁和易读。这在模板编程和泛型编程中特别有用，可以减少代码量并增加灵活性。

2. library features

2.1. Type traits

在C++11中，类型特征（type traits）是一组用于检查和操作类型属性的模板类和函数。它们提供了一种强大的方式来查询和操作类型的静态特征，从而使代码更加通用和可重用。VS2005部分支持，VS2015全部支持。
C++11标准库提供了许多类型特征，其中一些包括：

• is_void：检查类型是否为void。
• is_pointer：检查类型是否为指针类型。
• is_integral：检查类型是否为整型类型。
• is_floating_point：检查类型是否为浮点类型。
• is_array：检查类型是否为数组类型。
• is_enum：检查类型是否为枚举类型。
• is_class：检查类型是否为类类型。
• is_function：检查类型是否为函数类型。
• is_same：检查两个类型是否相同。

我们可以使用这些类型特征来编写更通用的代码，并根据不同的类型特征采取不同的行动。例如，假设我们有一个名为"print_value"的函数模板，它接受一个值并打印出它。我们可以使用is_integral类型特征来决定如何打印该值：

template<typename T>
void print_value(T value) {
    if (std::is_integral<T>::value) {
        std::cout << std::dec << value << std::endl;
    } else {
        std::cout << value << std::endl;
    }
}

在上述示例中，我们使用std::is_integral类型特征检查T类型是否为整型类型。如果是，我们将该值打印为十进制数；否则，我们将该值打印为普通值。
总之，类型特征是C++11引入的一项非常有用的功能，它们可以使代码更加通用和可重用，并根据不同的类型特征采取不同的行动。这对于模板编程和泛型编程非常有用，可以帮助我们编写更健壮和灵活的代码。

2.2. Garbage Collection and Reachability-Based Leak Detection

C++11不提供内置的垃圾回收机制，这意味着程序员需要手动管理内存。但是，手动管理内存容易出错，并且经常会导致内存泄漏和悬空指针等问题。为了避免这些问题，C++11引入了一种新的内存泄漏检测机制——基于可达性（reachability）的泄漏检测。VS2010部分支持，VS2015全部支持。
在基于可达性的泄漏检测中，程序通过跟踪内存对象之间的引用关系来确定哪些对象可以被访问（即可达），哪些对象已经无法访问（即不可达）。如果一个对象不可达，则说明它已经成为了内存泄漏。

2.2.1. shared_ptr

C++11标准库中提供了一个名为"shared_ptr"的智能指针类，它使用基于可达性的泄漏检测来自动管理内存，并防止内存泄漏。"shared_ptr"智能指针实现了引用计数技术，即它维护一个计数器来记录有多少个指针指向同一块内存。当计数器变为0时，这块内存就会被释放。
例如，假设我们有一个名为"Person"的类，它包含一个名为"name"的字符串和一个名为"address"的指向另一个"Address"类对象的智能指针。我们可以使用"shared_ptr"智能指针来自动管理"address"指针，并确保它在不再需要时被正确释放：

#include 
#include 

class Address {
public:
std::string street;
std::string city;
};

class Person {
public:
std::string name;
std::shared_ptr<Address> address;
};

int main() {
    std::shared_ptr<Person> person = std::make_shared<Person>();
    person->name = "Alice";
    person->address = std::make_shared<Address>();
    person->address->street = "123 Main St";
    person->address->city = "Anytown";

    std::cout << person->name << " lives at " << person->address->street << ", " << person->address->city << std::endl;
    return 0; // memory is automatically released
}

在上述示例中，我们使用"shared_ptr"智能指针来管理"Person"类和"Address"类对象之间的引用关系。由于"person"对象拥有一个指向"address"对象的智能指针，因此"address"对象始终是可达的，并且只有在"person"对象销毁时才会被释放。

2.2.2. unique_ptr

其中一个是"unique_ptr"智能指针，它与"shared_ptr"智能指针类似，但只能有一个指针指向同一块内存。这意味着"unique_ptr"适用于需要严格拥有所有权的情况，并且可以有效地防止多个指针同时释放同一块内存的情况。
例如，假设我们有一个名为"Person"的类，它包含一个名为"name"的字符串和一个名为"address"的指向另一个"Address"类对象的"unique_ptr"智能指针。我们可以使用"unique_ptr"智能指针来确保"address"指针在不再需要时被正确释放：

#include 
    #include 

    class Address {
public:
std::string street;
std::string city;
};

class Person {
public:
std::string name;
std::unique_ptr<Address> address;
};

int main() {
    std::unique_ptr<Person> person(new Person);
    person->name = "Alice";
    person->address.reset(new Address);
    person->address->street = "123 Main St";
    person->address->city = "Anytown";

    std::cout << person->name << " lives at " << person->address->street << ", " << person->address->city << std::endl;
    return 0; // memory is automatically released
}

在上述示例中，我们使用"unique_ptr"智能指针来管理"Person"类和"Address"类对象之间的引用关系。由于"person"对象拥有一个指向"address"对象的"unique_ptr"智能指针，因此"address"对象始终只有一个所有者，并且只有在"person"对象销毁时才会被释放。

2.2.3. weak_ptr

当涉及到内存管理和智能指针时，C++11还引入了一种名为"weak_ptr"的智能指针。与"shared_ptr"智能指针不同，"weak_ptr"智能指针不会增加指向对象的引用计数，并且不会阻止对象的销毁。因此，“weak_ptr"通常用于解决循环引用（circular reference）问题。
循环引用是指两个或多个对象相互引用，形成一个环形结构。这种情况通常会导致内存泄漏，因为对象之间的相互引用会使得它们的引用计数始终不为0，从而无法正确释放内存。
例如，假设我们有两个类"Person"和"Car”，它们分别包含一个指向另一个类对象的智能指针。如果我们创建一个"Person"对象和一个"Car"对象，并将它们相互引用，就会形成一个循环引用的结构：

#include 
#include 

class Car;

class Person {
public:
std::string name;
std::shared_ptr<Car> car;
};

class Car {
public:
std::string make;
std::weak_ptr<Person> driver;
};

int main() {
    std::shared_ptr<Person> person = std::make_shared<Person>();
    std::shared_ptr<Car> car = std::make_shared<Car>();
    person->car = car;
    car->driver = person;

    std::cout << "Person " << person->name << " is driving a " << car->make << std::endl;
    return 0;
}

在上述示例中，"Person"对象和"Car"对象相互引用，形成了一个循环引用的结构。由于"Person"对象和"Car"对象都使用了"shared_ptr"智能指针，它们之间的引用计数始终不为0，从而无法正确释放内存。
为了解决这个问题，我们可以使用"weak_ptr"智能指针来打破循环引用。"weak_ptr"智能指针不会增加引用计数，因此即使两个对象之间存在互相引用的情况，也不会导致引用计数错误：
在上述示例中，我们使用"weak_ptr"智能指针来打破循环引用。由于"weak_ptr"不会增加引用计数，因此即使两个对象之间存在互相引用的情况，它们的引用计数也不会变化。在上述示例中，我们将"Person"对象和"Car"对象分别赋值给"weak_person"和"weak_car"智能指针，并使用"lock"函数来获取它们的"shared_ptr"智能指针。这样，我们就可以避免了循环引用的问题，并正确地释放内存。
总之，当涉及到内存管理和智能指针时，smart_ptr是C++11引入的一种非常有用的工具，它可以帮助程序员解决循环引用的问题，并避免内存泄漏和悬空指

2.3. Money, Time, and hexfloat I/O manipulators

C++11引入了几个新的I/O操作符和I/O操纵符，包括Money、Time和hexfloat。这些操作符和操纵符可以让程序员更轻松地处理各种数据类型，并进行格式化输入输出。VS2010部分支持，VS2015全部支持。

2.3.1. Money I/O 操作符

Money操作符提供了一种方便的方法来读取和写入货币值。它基于一个名为"money_get"的标准C++ facet，可以自动识别并转换各种货币格式。
例如，我们可以使用Money操作符来读取一个美元金额：

#include 
#include 

int main() {
    double amount;
    std::cin >> std::get_money(amount, true);
    std::cout << "Amount: " << amount << std::endl;
    return 0;
}

在上述示例中，我们使用"get_money"函数和"true"参数来创建一个Money操作符，并将其传递给"cin"对象。当用户输入一个货币值时，Money操作符会自动识别和转换该值，并存储在"amount"变量中。

2.3.2. Time I/O 操作符

Time操作符提供了一种方便的方法来读取和写入时间值。它基于一个名为"time_get"的标准C++ facet，可以自动识别并转换各种时间格式。
例如，我们可以使用Time操作符来读取当前时间：

#include 
#include 
#include 

int main() {
    auto now = std::chrono::system_clock::now();
    std::time_t time = std::chrono::system_clock::to_time_t(now);
    std::cin >> std::get_time(std::localtime(&time), "%c");
    std::cout << "Time: " << std::put_time(std::localtime(&time), "%c") << std::endl;
    return 0;
}

在上述示例中，我们使用"std::chrono"库来获取当前时间，并将其转换为"std::time_t"类型。然后，我们使用"get_time"函数和"%c"格式来创建一个Time操作符，并将其传递给"cin"对象。当用户输入一个时间值时，Time操作符会自动识别和转换该值，并存储在"std::tm"结构体中。最后，我们使用"std::put_time"函数和"%c"格式来格式化输出时间值。

2.3.3. hexfloat I/O 操纵符

hexfloat操纵符提供了一种方便的方法来读取和写入十六进制浮点数。它基于一个名为"num_get"的标准C++ facet，可以自动识别并转换各种浮点数格式。
例如，我们可以使用hexfloat操纵符来读取一个十六进制浮点数：

#include 
#include 

int main() {
    double value;
    std::cin >> std::hexfloat >> value;
    std::cout << "Value: " << std::defaultfloat << value << std::endl;
    return 0;
}

在上述示例中，我们使用"std::hexfloat"操纵符来创建一个十六进制浮点数操作符，并将其传递给"cin"对象。当用户输入一个十六进制浮点数时，hexfloat操作符会自动识别和转换该值，并存储在"value"变量中。最后，我们使用"std::defaultfloat"操纵符来恢复默认的浮点数格式，并使用"std::cout"输出"value"变量。
总之，C++11引入了Money、Time和hexfloat操作符和操纵符等新的I/O功能，可以帮助程序员更轻松地处理各种数据类型，并进行格式化输入输出。这些操作符和操纵符基于标准facet，具有良好的可移植性和兼容性，可以有效地提高代码的可读性和可维护性。

2.4. Disallowing COW (copy-on-write) string

在C++11中，为了避免潜在的性能问题，当字符串使用Copy-On-Write（COW）技术时，提供了一个选项来禁止这种行为。VS2010部分支持，VS2015全部支持。
Copy-On-Write是一种优化技术，用于避免不必要的内存分配和复制。当一个字符串被复制时，COW技术会创建一个共享底层数据的副本，而不是立即分配新的内存。只有在副本发生更改时，才会分配新的内存。这种方法可以显著提高程序的效率，特别是在处理大量字符串时。
然而，COW技术也可能导致一些性能问题。如果多个对象共享同一个字符串，那么每次更改该字符串的任何对象都需要先创建该字符串的独立副本，从而导致额外的内存分配和复制操作。这可能会影响程序的性能，并且可能会导致不可预测的行为。
为了避免这些问题，C++11提供了一个选项来禁用字符串的COW行为。这可以通过设置"std::basic_string::allocator_type::propagate_on_container_copy_assignment"、"std::basic_string::allocator_type::propagate_on_container_move_assignment"和"std::basic_string::allocator_type::propagate_on_container_swap"等属性来实现。
例如，我们可以定义一个不支持COW的字符串类型：

#include 
#include 

typedef std::basic_string<char, std::char_traits<char>, 
std::allocator<char>> my_string;

int main() {
    my_string a = "foo";
    my_string b = a;
    std::cout << "a: " << a << ", b: " << b << std::endl; // a: foo, b: foo

    b[0] = 'b';
    std::cout << "a: " << a << ", b: " << b << std::endl; // a: foo, b: boo
    return 0;
}

在上述示例中，我们使用"std::basic_string"定义了一个不支持COW的字符串类型"my_string"。当我们将一个字符串复制到另一个字符串时，COW技术将被禁用，并且将创建一个新的字符串对象。由于两个字符串没有共享底层数据，因此更改一个字符串不会影响另一个字符串。
总之，C++11提供了一种选项来禁止字符串的COW行为，以避免潜在的性能问题。通过设置相关属性，程序员可以选择启用或禁用该功能，并根据具体情况进行优化和调整。

2.5. Regular expressions library

C++11引入了正则表达式库（Regular Expressions Library），其中包括了一组类和函数，用于处理字符串模式匹配。
使用C++11的正则表达式库，我们可以：

• 定义一个正则表达式模式
• 搜索字符串中与模式匹配的内容
• 替换字符串中与模式匹配的内容
• 提取子串

例如，我们可以使用C++11的正则表达式库来搜索一个字符串中的数字：

#include 
#include 

int main() {
    std::string str = "abc123def456";
    std::regex pattern("\\d+");
    std::smatch match;

    if (std::regex_search(str, match, pattern)) {
        std::cout << "Match found: " << match[0] << std::endl;
    } else {
        std::cout << "No match found" << std::endl;
    }
    return 0;
}

在上述示例中，我们定义了一个正则表达式模式"\d+“，它表示一个或多个数字。然后，我们使用"std::regex_search"函数在字符串"str"中搜索与该模式匹配的内容，并将结果存储在"match"对象中。最后，我们输出匹配到的内容。
除了"std::regex_search"函数外，C++11的正则表达式库还提供了其他一些函数和类，如"std::regex_match”、“std::regex_replace”、"std::regex_iterator"等，用于执行更复杂的操作。
总之，C++11的正则表达式库提供了一组类和函数，用于处理字符串模式匹配。使用正则表达式库，程序员可以轻松地定义、搜索、替换和提取字符串中的内容，并且可以更高效、更安全地处理各种字符串操作。

2.6. Other Headers

2.7. Library features

• concurrency support library
• emplace() and other use of rvalue references throughout all parts of the existing library
• shrink_to_fit for vector
• std::unique_ptr
• std::move_iterator
• std::initializer_list
• stateful and scoped allocators
• std::forward_list
• chrono library
• ratio library
• new algorithms:
• std::all_of, std::any_of, std::none_of,
• std::find_if_not,
• std::copy_if, std::copy_n,
• std::move, std::move_backward,
• std::random_shuffle, std::shuffle,
• std::is_partitioned, std::partition_copy, std::partition_point,
• std::is_sorted, std::is_sorted_until,
• std::is_heap, std::is_heap_until,
• std::minmax, std::minmax_element,
• std::is_permutation,
• std::iota,
• std::uninitialized_copy_n
• Unicode conversion facets
• std::function
• std::exception_ptr
• std::error_code and std::error_condition
• iterator improvements:
• std::begin
• std::end
• std::next
• std::prev
• Unicode conversion