C++11 核心新特性涵盖可变参数模板、移动语义增强及 STL 容器更新。可变参数模板允许定义任意数量参数的函数和类模板，通过参数包展开机制实现编译时多态。类功能方面新增了移动构造函数和移动赋值运算符，配合 default 和 delete 关键字管理默认行为，final 和 override 控制继承策略。STL 引入 unordered 系列容器、emplace 系列接口优化内存构造，并支持基于范围的 for 循环遍历。这些改进提升了代码的灵活性、性能和可维护性。
Args...，参数类型是 Args...template<class ...Args> void Func(Args... args) {}template<class ...Args> void Func(Args&... args) {}template<class ...Args> void Func(Args&&... args) {}class... 或 typedef... 指出接下来的参数表示零或多个类型列表；在函数参数列表中，类型名后面跟 ... 指出接下来表示零或多个形参对象列表；函数参数包可以用左值引用或右值引用表示。每个参数实例化时遵循折叠规则。sizeof... 运算符计算参数包中参数的个数（不是 sizeof，这是一个新的运算符）。template <class ...Args> void Print(Args&&... args) // 0-N 个参数 {
cout << sizeof...(args) << endl;
}
int main() {
double x = 2.2;
Print(); // 包里有 0 个参数
Print(1); // 包里有 1 个参数
Print(1, string("xxx")); // 包里有 2 个参数
Print(1, string("xxx"), x); // 包里有 3 个参数
return 0;
}
原理说明：
void Print();void Print(int&& arg1);void Print(int&& arg1, string&& arg2);void Print(double&& arg1, string&& arg2, double& arg3); (x 是左值，所以 double&)...）来触发扩展操作。for(size_t i = 0; i < sizeof...(args); i++) 是运行时获取和编译，所以不支持这样使用。表达式 (参数包)...，... 必须写在整个表达式的末尾，用来触发'对每个参数都执行一次表达式'的展开逻辑。例如：GetArg(args)... 的作用是：把参数包里的每个元素，分别传给 GetArg 函数，然后把所有 GetArg 的返回值，组成一个新的参数列表。void ShowList() { // 编译器时递归的终止条件，参数包是 0 个时，直接匹配这个函数
cout << endl;
}
template<class T,class ...Args> void ShowList(T x, Args... args) {
cout << x << " ";
// args 是 N 个参数的参数包，调用 ShowList，参数包的第一个传给 x，剩下 N-1 个传给第二个参数包
ShowList(args...);
}
template<class ...Args> void Print(Args... args) {
ShowList(args...);
}
int main() {
Print();
Print(1);
Print(1, string("xxx"));
Print(1, string("xxx"), 2.2);
return 0;
}
底层细节：
当调用 Print(1, string("xxxxx"), 2.2) 时，编译器将可变参数模板通过模式的包扩展，推导出的重载函数如下：
void ShowList(double z) { cout << z << " "; ShowList(); }
void ShowList(string y, double z) { cout << y << " "; ShowList(z); }
void ShowList(int x, string y, double z) { cout << x << " "; ShowList(y, z); }
void Print(int x, string y, double z) { ShowList(x, y, z); }
template <class T> const T& GetArg(const T& x) {
cout << x << " ";
return x;
}
template <class ...Args> void Arguments(Args... args) { }
template <class ...Args> void Print(Args... args) {
Arguments(GetArg(args)...); // GetArg(args)... 表示要展开，传入三个参数
// 实例化出 Arguments(GetArg(x), GetArg(y), GetArg(z));
// 编译时展开为：Arguments(GetArg(1), GetArg(string("xxxxx")), GetArg(2.2));
}
int main() {
Print(1, string("xxxxx"), 2.2);
return 0;
}
emplace_back 和 push_back 是一样的；部分场景下，emplace 可以直接构造，push 和 insert 是 构造 + 移动构造 或 构造 + 拷贝构造。int main() {
list<ssp::string> lt;
// 传左值，跟 push_back 一样，走拷贝构造
ssp::string s1("111111"); // string(char* str) -- 构造
lt.emplace_back(s1); // string(const string& s) -- 拷贝构造
cout << "*********************************" << endl;
// 右值，跟 push_back 一样，走移动构造
lt.emplace_back(move(s1)); // string(string&& s) -- 移动构造
cout << "*********************************" << endl;
// 直接把构造 string 参数包往下传，直接用 string 参数包构造 string
// 这里达到的效果是 push_back 做不到的
lt.emplace_back("11111"); // string(char* str) -- 构造
cout << "*********************************" << endl;
list<pair<ssp::string, int>> lt1;
// 跟 push_back 一样
// 构造 pair + 拷贝/移动构造 pair 到 list 的节点中 data 上
pair<ssp::string, int> kv("苹果", 1); // string(char* str) -- 构造
lt1.emplace_back(kv); // string(const string& s) -- 拷贝构造
cout << "*********************************" << endl;
// 跟 push_back 一样
lt1.emplace_back(move(kv)); // string(string&& s) -- 移动构造
cout << "*********************************" << endl;
// 直接把构造 pair 参数包往下传，直接用 pair 参数包构造 pair
lt(, );
cout << << endl;
;
}
// 构造函数
template <class ...Args> ListNode(Args&&... args) : _next(nullptr) , _prev(nullptr) , _data(std::forward<Args>(args)...) {}
// emplace_back 实现
template <class ...Args> void emplace_back(Args&&... args) {
insert(end(), std::forward<Args>(args)...);
}
template <class... Args> 或 template <typename... Args>// ... 跟在 Args 后面，声明 Args 是'类型参数包'（装 0~N 个类型）
template <class... Args> void Print(Args&&... args); // 这里的 Args 就是上面声明的类型包
void Func(T... args)（T 是类型，args 是值参数包）// 先声明类型包 Ts，再用 Ts... 声明值参数包 args
template <typename... Ts> void Func(Ts... args) {
// args 是值参数包，装 0~N 个值
}
GetArg(args) 是'包含参数包的表达式'，... 跟在这个表达式后面，才会对每个参数执行一次 GetArgtemplate <class... Args> void Print(Args&&... args) {
// 核心：GetArg(args)... 是'表达式 (参数包)...'，...在末尾触发展开
Arguments(GetArg(args)...); // 展开逻辑（编译时）：
// Print(1, "xxx", 2.2) → Arguments(GetArg(1), GetArg("xxx"), GetArg(2.2))
}
template <typename... Ts> void PrintSize(Ts... args) {
// 展开参数包，计算每个参数的大小，存入数组
int sizes[] = {sizeof...(args)...}; // 注意：此处修正为 sizeof...(args) 以符合语法
// 展开逻辑：
// PrintSize(1, "xxx", 2.2) → int sizes[] = {sizeof(1), sizeof("xxx"), sizeof(2.2)};
for (auto s : sizes) {
cout << s << " "; // 输出：4 4 8（不同编译器可能有差异）
}
}
// 递归终止函数（参数包为空时调用）
void RecursivePrint() {
cout << endl;
}
// 递归展开函数（拆出第一个参数，剩下的继续递归）
template <typename T, typename... Ts> void RecursivePrint(T first, Ts... rest) {
cout << first << " ";
RecursivePrint(rest...); // ...跟在 rest 后面，展开剩余参数包
}
// 调用：RecursivePrint(1, "xxx", 2.2);
// 执行流程：
// 1. RecursivePrint(1, "xxx", 2.2) → 输出 1，调用 RecursivePrint("xxx", 2.2)
// 2. RecursivePrint("xxx", 2.2) → 输出 xxx，调用 RecursivePrint(2.2)
// 3. RecursivePrint(2.2) → 输出 2.2，调用 RecursivePrint()
// 4. RecursivePrint() → 输出换行，结束
template <class... Args> void Print(Args&&... args) {
// Args&&... 是'万能引用的参数包'
// Args&& 是万能引用，... 是参数包展开，两者结合表示'0~N 个万能引用参数'
}
class Person {
public:
Person(const char*, int age = 0) :_name(name) ,_age(age) { }
private:
ssp::string _name;
int _age;
};
int main() {
Person s1;
Person s2 = s1; // string(const string& s) -- 拷贝构造
Person s3 = std::move(s1); // string(string&& s) -- 移动构造
Person s4;
s4 = std::move(s2); // string& operator=(string&& s) -- 移动赋值
return 0;
}
default 强制生成某个默认的函数，比如我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用 default 关键字显示指定移动构造生成。=delete 即可，该语法指示编译器不生产对应函数的默认版本，称 =delete 修饰的函数为删除函数。class Person {
public:
Person(const char*, int age = 0) :_name(name) ,_age(age) { }
//Person(const Person& p) // :_name(p._name) // ,_age(p._age) //{ }
Person(Person&& p) = default; // 强制生成移动构造
Person(const Person& p) = delete; // 限制生成拷贝构造（禁止调用）
private:
ssp::string _name;
int _age;
};
int main() {
Person s1;
// Person s2 = s1; // 不能使用拷贝构造
Person s3 = std::move(s1);
return 0;
}
final 修饰。class Car {
public:
virtual void Drive() final {} // 修正拼写 Dirve -> Drive
};
class Benz :public Car {
public:
// error C3248: "Car::Drive": 声明为 "final" 的函数不能由 "Benz::Drive" 重写
virtual void Drive() { cout << "Benz 舒适" << endl; }
};
override 可以帮助用户检测是否正确重写了虚函数 (若是重写正确无影响，不正确会直接报错)。class Car {
public:
virtual void Drive() {}
};
class Benz :public Car {
public:
virtual void Drive() override { cout << "Benz 舒适" << endl; }
};
unordered_map，unordered_set，array，forward_list。initializer_list 版本的构造。for(auto& elem : container)。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online