1.C++11中引入了哪些新的智能指针类型？请描述它们的用法和区别。
C++11中引入了三种新的智能指针类型：std::unique_ptr, std::shared_ptr, 和 std::weak_ptr。
-
std::unique_ptr:-
用法:
std::unique_ptr是一种独占所有权的智能指针，即同一时间内只能有一个std::unique_ptr指向一个给定的对象。当std::unique_ptr被销毁时，它所指向的对象也会被自动删除。 -
例子:
std::unique_ptr<int> ptr(new int(10));
-
-
std::shared_ptr:-
用法:
std::shared_ptr是一种共享所有权的智能指针，即多个std::shared_ptr可以同时指向同一个对象。对象的最后一个std::shared_ptr被销毁时，该对象才会被删除。 -
例子:
std::shared_ptr<int> ptr1(new int(20)); std::shared_ptr<int> ptr2 = ptr1; // 现在两个shared_ptr共享同一个对象
-
-
std::weak_ptr:-
用法:
std::weak_ptr是一种不控制对象生命周期的智能指针，它是为了解决std::shared_ptr相互引用导致的循环引用问题而设计的。std::weak_ptr需要与std::shared_ptr一起使用，它可以从一个std::shared_ptr或另一个std::weak_ptr创建，但它不会增加引用计数。 -
例子:
std::shared_ptr<int> sharedPtr(new int(30)); std::weak_ptr<int> weakPtr(sharedPtr);
-
区别:
std::unique_ptr用于独占所有权的场景，只能有一个指针指向对象，适用于资源管理。std::shared_ptr用于共享所有权的场景，可以有多个指针指向同一个对象，适用于多个对象需要访问同一资源的情况。std::weak_ptr用于辅助std::shared_ptr，解决循环引用问题，不控制对象的生命周期。
2.解释一下C++11中的右值引用和移动语义，以及它们如何提高性能。
在C++11中，引入了右值引用和移动语义，主要目的是为了提高性能，尤其是在涉及到大量数据拷贝的场景中。
-
右值引用:
-
定义: 右值引用是一种引用，它可以绑定到一个临时对象（右值）上，但不能绑定到一个持久对象（左值）上。右值引用使用
&&符号表示。 -
例子:
int&& rvalueRef = 10; // 10是一个右值
-
-
移动语义:
-
定义: 移动语义允许资源的所有权从一个对象转移到另一个对象，这意味着不需要进行资源的复制，从而提高性能。移动语义通常通过移动构造函数和移动赋值运算符实现。
-
例子:
class MyClass { public: MyClass(MyClass&& other) noexcept : data(std::move(other.data)) { other.data = nullptr; // 移动后，将原对象的资源置为空 } MyClass& operator=(MyClass&& other) noexcept { if (this != &other) { delete data; data = other.data; other.data = nullptr; } return *this; } private: int* data; };
-
如何提高性能:
- 减少拷贝: 通过移动语义，可以将对象的资源直接转移给另一个对象，而不是复制一份新的资源。这在处理大型数据或资源密集型对象时尤其有用，因为避免了不必要的拷贝操作，从而节省了时间和内存。
- 优化临时对象的使用: 当编译器遇到临时对象时，它可以使用右值引用和移动语义来优化代码，从而减少创建和销毁临时对象的开销。
总的来说，右值引用和移动语义是C++11中非常重要的特性，它们在提高性能方面起着关键作用，尤其是在涉及到大量数据处理和资源管理的场景中。
3.谈谈你对C++11中引入的auto关键字的理解，它在什么情况下特别有用？
在C++11中，auto 关键字被引入作为一种类型推断的机制，它允许编译器自动推断变量的类型。
理解:
- 使用
auto关键字时，你不需要显式地指定变量的类型，编译器会根据变量的初始化表达式来推断其类型。 auto可以用于局部变量、函数参数、返回类型等场景。
特别有用的情况:
-
迭代器: 当你使用STL容器（如
std::vector,std::map等）时，迭代器的类型可能非常复杂。使用auto可以简化代码并提高可读性。std::vector<int> vec = {1, 2, 3, 4, 5}; for (auto it = vec.begin(); it != vec.end(); ++it) { // 使用迭代器it } -
范围for循环: 在范围for循环中，
auto可以自动推断元素的类型，使代码更简洁。for (auto& element : vec) { // 使用元素element } -
函数返回类型推断: 在C++14中，
auto还可以用于推断函数的返回类型。auto add(int x, int y) { return x + y; } -
泛型编程: 在泛型编程中，当类型参数非常复杂或者难以显式指定时，
auto可以简化代码。template<typename T> void process(const std::vector<T>& vec) { for (auto& element : vec) { // 处理元素element } }
总的来说，auto 关键字在C++11中的引入极大地提高了代码的可读性和编写的便捷性，特别是在处理复杂类型、泛型编程以及STL容器和算法时，auto 的使用可以显著简化代码。
4.C++11中的lambda表达式是什么？如何使用它们？
C++11中引入的lambda表达式是一种方便的编写匿名函数对象的方式。它们常用于短小的函数体，特别是在需要作为参数传递给算法或其他函数的情况下。
基本语法:
[捕获列表](参数列表) -> 返回类型 {
函数体
}
- 捕获列表: 定义了lambda表达式可以访问的外部变量，可以是值捕获、引用捕获或隐式捕获。
- 参数列表: 类似于普通函数的参数列表，用于定义传递给lambda表达式的参数。
- 返回类型: 可以显式指定lambda表达式的返回类型，也可以让编译器自动推断。
- 函数体: 定义了lambda表达式的执行逻辑。
使用示例:
-
基本使用:
auto add = [](int a, int b) -> int { return a + b; }; int sum = add(3, 5); // 调用lambda表达式 -
作为函数参数:
std::vector<int> vec = {1, 2, 3, 4, 5}; std::sort(vec.begin(), vec.end(), [](int a, int b) { return a > b; // 降序排序 }); -
捕获外部变量:
- 值捕获:
[=]捕获所有外部变量的副本。 - 引用捕获:
[&]捕获所有外部变量的引用。 - 混合捕获:
[x, &y]捕获变量x的副本和变量y的引用。
int x = 10; auto check = [x](int val) { return val > x; }; bool result = check(15); // true - 值捕获:
总结:
Lambda表达式是C++11中的一个强大特性，它提供了一种简洁的方式来定义匿名函数对象，非常适合用于STL算法、事件处理、回调函数等场景。通过合理使用lambda表达式，可以使代码更加简洁易读。
5.描述C++11中的nullptr与C++98中的NULL的区别。
在C++11中，引入了nullptr关键字，它是一个特殊的空指针字面量，用于解决C++98中使用NULL带来的一些问题。
C++98中的NULL:
NULL在C++98中通常被定义为0或者((void*)0)，它是一个宏。- 使用
NULL时存在一些问题，例如：NULL实际上是整数0，这可能导致类型模糊，尤其是在函数重载的情况下。- 使用
NULL作为指针的字面量时，编译器可能无法确定其类型，这可能会导致一些意外的行为。
C++11中的nullptr:
nullptr是一个特殊的字面量，它有自己的类型nullptr_t，可以自动转换为任何指针类型，但不能转换为整数类型。- 使用
nullptr可以避免C++98中使用NULL时的类型模糊问题，使代码更加清晰和安全。 - 在函数重载的场景下，
nullptr可以明确地表示空指针，从而避免与整数0的混淆。
示例:
假设我们有两个重载的函数：
void func(int x) {
// 处理整数
}
void func(int* ptr) {
// 处理指针
}
在C++98中，调用func(NULL)时，NULL会被解释为整数0，因此会调用第一个重载函数。而在C++11中，调用func(nullptr)时，nullptr会被识别为指针类型，因此会调用第二个重载函数。
总的来说，C++11中引入的nullptr提供了一种更安全、更明确的方式来表示空指针，解决了C++98中使用NULL可能导致的一些问题。
6.C++11标准库中有哪些新特性或改进？请举例说明。
C++11标准库引入了许多新特性和改进，下面是一些重要的新特性和改进：
-
智能指针 (
<memory>):- 引入了
std::unique_ptr,std::shared_ptr, 和std::weak_ptr用于更安全和便捷的内存管理。
- 引入了
-
线程支持库 (
<thread>,<mutex>,<condition_variable>,<future>):- 提供了对多线程编程的支持，包括线程的创建和管理(
std::thread), 互斥锁(std::mutex), 条件变量(std::condition_variable), 以及未来和承诺(std::future和std::promise)等。
- 提供了对多线程编程的支持，包括线程的创建和管理(
-
容器改进:
- 引入了新的容器如
std::array和std::unordered_map,std::unordered_set(基于哈希表的无序容器)。 - 容器现在支持范围构造函数和范围
insert方法。
- 引入了新的容器如
-
正则表达式库 (
<regex>):- 提供了对正则表达式的支持，包括正则表达式的匹配、搜索和替换功能。
-
随机数生成库 (
<random>):- 提供了更强大和灵活的随机数生成器和分布。
-
时间库改进 (
<chrono>):- 引入了新的时间库，用于表示时间点、时间段以及时钟。
-
元组 (
<tuple>):- 引入了
std::tuple，用于存储固定数量的异质元素。
- 引入了
-
Lambda表达式支持:
- 标准库的算法现在可以和lambda表达式更好地配合使用。
-
类型特性 (
<type_traits>):- 提供了一系列用于编译时类型信息查询和操作的工具。
-
移动语义支持:
- 容器和其他标准库组件增加了对移动语义的支持，提高了性能。
示例:
使用std::unordered_map创建一个基于哈希表的无序映射：
#include <iostream>
#include <unordered_map>
int main() {
std::unordered_map<std::string, int> wordCount = {
{"hello", 1},
{"world", 2}
};
wordCount["example"] = 3;
for (const auto& pair : wordCount) {
std::cout << pair.first << ": " << pair.second << std::endl;
}
return 0;
}
这只是C++11标准库中新特性和改进的一小部分，C++11标准库的改进和新特性极大地提高了C++的表达力和性能，并简化了许多常见编程任务的处理。
7.解释一下C++11中的范围for循环（range-based for loop）及其用法。
C++11中引入了范围for循环（range-based for loop），它提供了一种更简洁的方式来遍历容器或数组中的所有元素。
基本语法:
for (declaration : range) {
// 循环体
}
- declaration: 定义一个变量，该变量将在循环的每次迭代中被赋予范围中的一个元素的值。这个变量可以是值类型，也可以是引用类型。
- range: 表示要遍历的范围，可以是数组、STL容器（如
std::vector,std::list,std::map等）或任何支持begin()和end()成员函数的类型。
使用示例:
-
遍历数组:
int arr[] = {1, 2, 3, 4, 5}; for (int val : arr) { std::cout << val << " "; } // 输出: 1 2 3 4 5 -
遍历容器:
std::vector<int> vec = {10, 20, 30, 40, 50}; for (int& val : vec) { val *= 2; // 修改元素值 } for (const int val : vec) { std::cout << val << " "; } // 输出: 20 40 60 80 100 -
遍历map:
std::map<std::string, int> wordCount = {{"hello", 1}, {"world", 2}}; for (const auto& pair : wordCount) { std::cout << pair.first << ": " << pair.second << std::endl; } // 输出: // hello: 1 // world: 2
总结:
范围for循环是C++11中的一个非常实用的特性，它使得遍历容器和数组变得更加简单和直观。通过使用范围for循环，你可以避免直接操作迭代器或者管理索引，从而使代码更加清晰和易于维护。
8.C++11中如何初始化一个数组或容器？请给出示例代码。
在C++11中，可以使用统一的初始化语法（也称为列表初始化）来初始化数组或容器。这种语法使用花括号 {} 来包含初始化元素。
初始化数组:
int arr[] = {1, 2, 3, 4, 5}; // 初始化一个整型数组
std::array<int, 5> stdArr = {1, 2, 3, 4, 5}; // 使用std::array初始化数组
初始化容器:
std::vector<int> vec = {1, 2, 3, 4, 5}; // 初始化一个std::vector
std::map<std::string, int> wordCount = {
{"hello", 1},
{"world", 2}
}; // 初始化一个std::map
std::set<int> numSet = {1, 2, 3, 4, 5}; // 初始化一个std::set
初始化复杂容器:
std::vector<std::pair<std::string, int>> vecOfPairs = {
{"one", 1},
{"two", 2},
{"three", 3}
}; // 初始化一个包含std::pair的std::vector
初始化类对象:
如果类有一个适当的构造函数，也可以使用列表初始化来初始化类的对象。
class Point {
public:
Point(int x, int y) : x(x), y(y) {}
private:
int x, y;
};
Point p = {1, 2}; // 使用列表初始化来初始化Point对象
总的来说，C++11中的列表初始化提供了一种统一且简洁的初始化语法，可以用于数组、容器以及类对象的初始化。它不仅使代码更加清晰，还有助于防止一些初始化时的错误。
9.谈谈C++11中的constexpr关键字及其用途。
在C++11中，引入了constexpr关键字，用于定义常量表达式。constexpr指定的变量或函数在编译时就必须有确定的值，这使得编译器能够在编译时对表达式进行求值，而不是在运行时。
用途:
-
定义编译时常量: 使用
constexpr定义的变量必须在编译时就能确定其值，这使得它们在性能敏感的代码中非常有用，因为它们可以用于数组大小、模板参数等需要编译时确定值的地方。constexpr int max_size = 100; int arr[max_size]; // 使用constexpr变量作为数组大小 -
编译时函数计算:
constexpr函数是指能用于常量表达式的函数。这意味着你可以在编译时调用这些函数，并且它们的返回值可以用于初始化constexpr变量或其他编译时表达式。constexpr int square(int x) { return x * x; } constexpr int squared_value = square(10); // 在编译时计算 -
模板元编程: 在模板元编程中，
constexpr可以用于在编译时进行计算，从而实现更高效的代码。template<int N> struct Factorial { static constexpr int value = N * Factorial<N - 1>::value; }; template<> struct Factorial<0> { static constexpr int value = 1; }; constexpr int factorial_5 = Factorial<5>::value; // 在编译时计算5的阶乘
总结:
constexpr关键字在C++11中的引入为编译时计算提供了强大的支持，它允许定义编译时常量和函数，从而提高代码的性能和安全性。在需要编译时确定值的场景中，如模板元编程、数组大小定义等，constexpr非常有用。
10.C++11中的delegate构造函数是什么？如何使用？
在C++11中，引入了委托构造函数（delegate constructor）的概念，它允许一个构造函数在初始化列表中调用类中的另一个构造函数。这种机制可以减少代码重复，提高构造函数的复用性。
基本用法:
在类定义中，你可以在一个构造函数的初始化列表中使用冒号 : 后跟另一个构造函数来实现委托。
class MyClass {
public:
MyClass(int a, int b) : x(a), y(b) {} // 主构造函数
MyClass(int a) : MyClass(a, 0) {} // 委托构造函数
private:
int x, y;
};
在上面的例子中，MyClass(int a) 构造函数委托给 MyClass(int a, int b) 构造函数，这样就避免了在两个构造函数中重复相同的初始化逻辑。
注意事项:
- 委托构造函数不能与成员初始化列表同时使用。
- 委托链不能形成循环，即一个构造函数不能直接或间接地委托给自己。
总结:
委托构造函数是C++11中的一个有用特性，它允许构造函数之间的复用，从而减少代码重复并提高代码的清晰度和维护性。在设计类时，合理使用委托构造函数可以简化构造函数的编写。
11.请解释C++11中的尾返回类型（trailing return type）及其优势。
在C++11中，引入了尾返回类型（trailing return type）的概念，允许在函数声明中使用 auto 关键字，并在参数列表之后使用 -> 符号来指定返回类型。这种语法在处理复杂的返回类型或依赖于函数参数的返回类型时特别有用。
基本语法:
auto functionName(parameters) -> returnType {
// 函数体
}
优势:
-
处理复杂的返回类型: 对于返回类型复杂或难以直接指定的情况，尾返回类型提供了一种更清晰的语法。
template <typename T, typename U> auto multiply(T x, U y) -> decltype(x * y) { return x * y; } -
依赖于参数的返回类型: 当函数的返回类型依赖于其参数类型时，尾返回类型可以提供更灵活的方式来指定返回类型。
template <typename T> auto get_value(T t) -> decltype(t.value()) { return t.value(); } -
与lambda表达式和auto一起使用: 尾返回类型与C++11中的其他特性（如
auto和 lambda表达式）结合使用时，可以提供更灵活和强大的编程方式。auto add = [](int x, int y) -> int { return x + y; };
总结:
尾返回类型是C++11中的一个重要特性，它提供了一种灵活且清晰的方式来指定函数的返回类型。特别是在处理复杂的返回类型或依赖于参数的返回类型时，尾返回类型能够显著提高代码的可读性和编写的灵活性。
12.C++11中引入了哪些新的容器？请描述它们的特点和用法。
在C++11中，引入了几个新的容器，包括std::array, std::forward_list, 和基于哈希的无序容器(std::unordered_map, std::unordered_set, std::unordered_multimap, 和 std::unordered_multiset)。
-
std::array:-
特点:
std::array是一个固定大小的数组容器，它封装了一个原生数组，提供了STL容器的接口，如迭代器、容量查询等。 -
用法:
std::array<int, 5> arr = {1, 2, 3, 4, 5}; for (int i : arr) { std::cout << i << " "; }
-
-
std::forward_list:-
特点:
std::forward_list是一个单向链表容器，它提供了高效的元素插入和删除操作。 -
用法:
std::forward_list<int> flist = {1, 2, 3}; flist.push_front(0); // 在链表前端插入元素 for (int i : flist) { std::cout << i << " "; }
-
-
基于哈希的无序容器:
-
特点: 这些容器包括
std::unordered_map,std::unordered_set,std::unordered_multimap, 和std::unordered_multiset。它们基于哈希表实现，提供了平均常数时间复杂度的元素查找、插入和删除操作。 -
用法 (
std::unordered_map为例):std::unordered_map<std::string, int> umap = {{"one", 1}, {"two", 2}}; umap["three"] = 3; // 插入新元素 for (const auto& pair : umap) { std::cout << pair.first << ": " << pair.second << std::endl; }
-
总结:
C++11中引入的新容器增强了标准库的功能，提供了更多的数据结构选择。std::array 提供了固定大小的数组支持，std::forward_list 提供了单向链表的实现，而基于哈希的无序容器提供了高效的查找和操作性能。这些新容器使得C++标准库更加强大和灵活。
13.解释一下C++11中的变参模板（variadic templates）及其应用场景。
在C++11中，引入了变参模板（variadic templates），它允许模板接受任意数量的模板参数。这使得编写能够处理不确定数量参数的泛型代码变得可能，从而提高了代码的灵活性和可重用性。
基本语法:
template<typename... Args>
void functionName(Args... args) {
// 函数体
}
typename... Args是一个模板参数包，表示可以接受任意数量的类型参数。Args... args是一个函数参数包，表示可以接受任意数量的函数参数。
应用场景:
-
泛型编程: 变参模板在泛型编程中非常有用，可以编写能够处理不同数量和类型参数的函数或类。
template<typename... Args> void print(Args... args) { (std::cout << ... << args) << std::endl; // C++17中的折叠表达式 } print(1, "Hello", 3.14); // 输出: 1Hello3.14 -
类型安全的可变参数函数: 使用变参模板可以实现类型安全的可变参数函数，避免了传统C语言中使用
va_list的不安全性。template<typename T, typename... Args> void print(T first, Args... args) { std::cout << first << " "; if constexpr (sizeof...(args) > 0) { print(args...); // 递归调用 } } print("Hello", 42, 3.14); // 输出: Hello 42 3.14 -
元组和类型列表: 变参模板可以用于实现元组（tuple）和类型列表（type list），这在模板元编程中非常有用。
template<typename... Types> class Tuple {}; Tuple<int, double, std::string> myTuple; // 一个包含int, double, std::string的元组
总结:
变参模板是C++11中的一个强大特性，它极大地增强了模板的灵活性和表达能力。通过使用变参模板，可以编写更通用、更灵活的泛型代码，从而提高代码的复用性和可维护性。在泛型编程、类型安全的可变参数函数以及模板元编程等领域，变参模板都有着广泛的应用。
14.谈谈C++11中的用户定义字面量（user-defined literals）及其用途。
在C++11中，引入了用户定义字面量（user-defined literals）的概念，允许程序员为字面量定义自己的后缀，从而创建自定义类型的字面量。这提供了一种更直观、更易于阅读的方式来表示特定类型的值。
基本语法:
// 返回类型 operator"" 后缀名(参数类型 参数名)
// 例如，定义一个用于表示长度的字面量后缀 _m
long double operator"" _m(long double length) {
return length; // 返回以米为单位的长度
}
在上面的示例中，operator"" _m 是一个用户定义的字面量操作符，它允许使用 _m 后缀来表示长度。例如，10.5_m 表示 10.5 米。
用途:
-
增强可读性: 用户定义字面量可以使代码更易于阅读和理解。例如，使用
_kg表示千克、_s表示秒等，可以直观地表示物理量。auto weight = 75.0_kg; // 表示75千克 auto time = 10.0_s; // 表示10秒 -
类型安全: 通过用户定义字面量，可以在编译时检查类型，避免类型错误，提高代码的安全性。
Distance d = 100.0_m; // Distance是自定义的距离类型 -
自定义处理: 用户定义字面量允许对字面量值进行自定义处理，例如单位转换、格式检查等。
std::string operator"" _hex(unsigned long long int n) { std::stringstream ss; ss << std::hex << n; return ss.str(); // 将整数转换为十六进制字符串 } auto hexStr = 255_hex; // "ff"
总结:
用户定义字面量是C++11中的一个有用特性，它提供了一种灵活的方式来扩展语言的字面量表示能力。通过定义自己的字面量后缀，可以增强代码的可读性、类型安全性，并实现自定义的处理逻辑。在表示特定类型的常量、进行单位转换等场景中，用户定义字面量都有着广泛的应用。
15.C++11中的std::thread库提供了哪些功能？请举例说明如何使用它创建和管理线程。
在C++11中，引入了std::thread库，它提供了对多线程编程的支持。std::thread库允许你创建和管理线程，使得编写并发程序变得更加简单和安全。
主要功能:
- 创建线程: 可以通过构造
std::thread对象来创建一个新线程，将要执行的函数和参数传递给构造函数。 - 等待线程完成: 使用
join()方法可以等待线程完成其任务。 - 分离线程: 使用
detach()方法可以将线程从std::thread对象分离，使线程在后台独立运行。 - 查询线程状态: 可以使用
joinable()方法检查线程是否可以被join或detach。 - 线程标识: 每个
std::thread对象都有一个与之关联的线程标识符，可以通过get_id()方法获取。
示例代码:
创建并等待线程完成：
#include <iostream>
#include <thread>
void printMessage(const std::string& message) {
std::cout << "Thread message: " << message << std::endl;
}
int main() {
std::thread t(printMessage, "Hello, World!"); // 创建线程
if (t.joinable()) {
t.join(); // 等待线程完成
}
return 0;
}
分离线程：
#include <iostream>
#include <thread>
#include <chrono>
void countDown(int seconds) {
while (seconds > 0) {
std::cout << seconds-- << " seconds remaining..." << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1));
}
std::cout << "Countdown finished." << std::endl;
}
int main() {
std::thread t(countDown, 5); // 创建线程
t.detach(); // 分离线程
// 主线程继续执行其他任务...
std::cout << "Main thread continues..." << std::endl;
// 给足够的时间让分离的线程完成
std::this_thread::sleep_for(std::chrono::seconds(6));
return 0;
}
总结:
std::thread库是C++11中引入的一个重要特性，它简化了多线程编程的过程。通过使用std::thread，你可以轻松地创建和管理线程，实现并发执行任务。在实际开发中，正确地使用std::thread库可以提高程序的性能和响应速度。
由于内容太多，更多内容以链接形势给大家，点击进去就是答案了
16. 解释一下C++11中的强类型枚举（strongly-typed enumerations）及其优势。
17. C++11中如何使用std::function和std::bind来处理回调函数？
18. 谈谈C++11中的默认和删除函数（defaulted and deleted functions）及其用途。
19. C++11中的std::chrono库提供了哪些时间相关的功能？请举例说明其用法。
20. 解释一下C++11中的显式转换运算符（explicit conversion operators）及其用法。
21. C++11中的std::initializer_list是什么？它如何用于构造函数和函数重载？
22. 谈谈C++11中的原子操作（atomic operations）及其在多线程编程中的应用。
23. C++11中的std::move语义是什么？如何使用它来优化性能？
24. 解释一下C++11中的完美转发（perfect forwarding）及其实现方式。
25. C++11中的std::forward_list容器是什么？它与其他容器有何不同？
26. 谈谈C++11中的alignas和alignof关键字及其用途。
27. C++11中的noexcept关键字用于什么目的？请给出示例代码说明其用法。
28. 解释一下C++11中的引用折叠规则（reference collapsing rules）及其应用场景。
582
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
