代码收藏家 C++ 列表初始化详解（一）：统一声明与STL中的变化，emplace的优化与move操作指南
目录
0. 回忆
1.隐式类型转化
特性 1.统一的列表初始化
1.{}初始化
2.2 std::initializer_list
二、声明
1.auto
2.decltype
3.nullptr
宏定义的例子
使用 const 和 enum 替代宏
4. 范围 for 循环
5.final与override
final 关键字
override 关键字
示例代码
智能指针
6. STL 中的一些变化
array
forward_list
unordered_map
使用 unordered_map 的基本步骤：
示例：
unordered_set
使用 unordered_set 的基本步骤：
示例：
注意事项：
新接口（4 点）
Java sun->甲骨文收购 商业化语言
查询链接：cppreference.com
0. 回忆
1.隐式类型转化
隐式类型转化（Implicit Type Conversion）：编译器自动将一种数据类型转换为另一种数据类型的过程，而无需程序员明确指示。这种转换通常发生在以下几种情况下：
- 赋值兼容性：当一个值被赋给另一个类型兼容的变量时，编译器可能会自动进行类型转换。例如，将一个
int类型的值赋给一个double类型的变量。
int a = 5;
double b = a; // 隐式类型转换：int 转换为 double- 表达式中的类型提升：在表达式中，编译器可能会将较小的数据类型自动提升为较大的数据类型，以避免数据丢失。
int a = 5;
double b = 3.14;
double result = a + b; // 隐式类型转换：a 从 int 转换为 double- 函数调用：当传递给函数的实参与函数参数类型不匹配时，如果存在隐式转换路径，编译器会自动进行类型转换。
void func(double x) {
// ...
}
int a = 10;
func(a); // 隐式类型转换：a 从 int 转换为 double- 算术运算：在进行算术运算时，编译器可能会将操作数转换为同一类型，以确保运算的正确性。
int a = 5;
float b = 2.5f;
float result = a * b; // 隐式类型转换：a 从 int 转换为 float隐式类型转换虽然方便，但也可能导致一些潜在的问题，比如精度损失、意外行为或难以发现的错误。因此，C++11 引入了 explicit 关键字来禁止某些构造函数或转换函数的隐式转换。
以下是一个使用 explicit 的例子：
class MyClass {
public:
explicit MyClass(int value) {
// ...
}
};
MyClass obj = 10; // 错误：不允许隐式类型转换
MyClass obj(10); // 正确：显式调用构造函数在这个例子中，MyClass 的构造函数被标记为 explicit，因此不能使用隐式类型转换来初始化 MyClass 的对象。
一.统一的列表初始化
1.{}初始化
int main()
{
int x = 1;
int y = { 2 };
int z{ 3 };
int a1[] = { 1,2,3 };
int a2[] { 1,2,3 };
// 本质都是调用构造函数
Point p0(0, 0);
Point p1 = { 1,1 }; // 多参数构造函数隐式类型转换
Point p2{ 2,2 };
const Point& r = { 3,3 };
int* ptr1 = new int[3]{ 1,2,3 };
Point* ptr2 = new Point[2]{p0,p1};
Point* ptr3 = new Point[2]{ {0,0},{1,1} };
return 0;
} Point* ptr3 = new Point[2]{ {0,0},{1,1} };2.2 std::initializer_list
initializer_list<int> il = { 10, 20, 30 };的实现
不同的规则
vector<int> v1 = { 1,2,3,4,3}; // 默认调用initializer_list构造函数，隐式类型转换，可扩容隐式类型转换是指编译器自动将初始化列表转换为一个 initializer_list 类型的对象，然后传递给 vector 的构造函数。这个转换过程是自动的。
Point p1 = { 1,1}; // 直接调用两个参数的构造 — 隐式类型转换，所以无法无限扩容int main()
{
vector<int> v1 = { 1,2,3,4,3}; // 默认调用initializer_list构造函数，隐式类型转换
Point p1 = { 1,1};
auto il = { 10, 20, 30 };
//initializer_list<int> il = { 10, 20, 30 };
cout << typeid(il).name() << endl;
cout << sizeof(il) << endl;
bit::vector<int> v2 = { 1,2,3,4,54};
for (auto e : v2)
{
cout << e << " ";
}
cout << endl；
return 0;
}- vector 底层调用的也是 initializer_list 的构造
2.对于 map 隐式类型转化也要括中括，因为默认有 pair 和 initializer 两个识别类型
//里面{}是调用日期类的构造函数生成匿名对象
//外面{}是日期类常量对象数组，去调用vector支持initializer_list的构造函数
vector<Date> v = { {1,1,1},{2,2,2},{3,3,3} };
//里面{}调用pair的构造函数生成pair匿名对象
//外面{}是pair常量对象数组，去调用map支持initializer_list的构造函数
map<string, string> dict = { {"sort","排序"},{"string","字符串"} };
3.注意容器initializer_list不能直接引用，必须加const，因为可以认为initializer_list是由常量数组转化得到的，临时对象具有常性。
//构造
List(const initializer_list<T>& l1)
{
empty_initialize();
for (auto& e : l1)
{
push_back(e);
}
}二、声明
1.auto
自动识别，定义变量
2.decltype
typeid().name() 打印识别类型，只能看一看
decltype 相对于 auto 就不一定要定义时传值了，主要有三点运用场景如下
template<class Func>
class B
{
private:
Func _f;
};
int main()
{
int i = 10;
auto p = &i;
auto pf = malloc;
//auto x;
cout << typeid(p).name() << endl;
cout << typeid(pf).name() << endl;
// typeid(pf).name() ptr; typeid推出类型是一个字符串，只能看不能用
auto pf1 = pf;
// decltype推出对象的类型，再定义变量，或者作为模板实参
//1. 单纯先定义一个变量出现
decltype(pf) pf2;
//2.传类函数
B<decltype(pf)> bb1;
const int x = 1;
double y = 2.2;
//3.识别返回值类型
B<decltype(x * y)> bb2;
return 0;
}3.nullptr
由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示 整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。
这里是C++的一个bug，使用NULL可能在类型匹配的时候出现问题，比如你期望匹配成指针结果匹配成了0。
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif尽量用const enum inline去替代宏，如下
宏定义的例子
传统的宏定义可能如下所示：
#define PI 3.14159
#define MAX_SIZE 100
#define ADD(a, b) ((a) + (b))使用 const 和 enum 替代宏
使用 const 和 enum 关键字可以提供类型安全，并且能够更好地与命名空间和作用域规则集成。
// 使用 const 替代数值宏
const double PI = 3.14159;
// 使用 enum 替代数值宏
enum { MAX_SIZE = 100 };
// 函数宏可以使用 inline 函数替代
inline int add(int a, int b) {
return a + b;
}4. 范围 for 循环
这个我们在前面的课程中已经进行了非常详细的讲解，这里就不进行讲解了，请参考 C++ 入门 + STL 容器部分的课件讲解。
5.final与override
详见在继承和多态的时候说过。
在C++中，final 和 override 关键字是在C++11标准中引入的，用于增强对继承和多态的支持。下面将通过一个简单的例子来演示这两个关键字的使用。
final关键字
final 关键字用于指定一个类不能被继承，或者一个虚函数不能被重写。
override关键字
override 关键字用于指示一个成员函数打算重写一个虚函数。如果基类中没有匹配的虚函数，编译器将报错。
示例代码
#include <iostream>
// 基类
class Base {
public:
// 声明一个虚函数
virtual void show() {
std::cout << "Base show function called." << std::endl;
}
// 声明一个虚析构函数
virtual ~Base() {}
};
// 派生类
class Derived : public Base {
public:
// 使用 override 关键字表明这是对基类虚函数的重写
void show() override {
std::cout << "Derived show function called." << std::endl;
}
// 使用 final 关键字表明这个函数不能在子类中被重写
virtual void print() final {
std::cout << "Derived print function called." << std::endl;
}
};
// 尝试从 Derived 派生一个新的类
class MoreDerived : public Derived {
public:
// 尝试重写 final 函数，这将导致编译错误
// void print() {
// std::cout << "MoreDerived print function called." << std::endl;
// }
};
int main() {
Base* b = new Derived();
b->show(); // 输出 "Derived show function called."
Derived* d = new Derived();
d->print(); // 输出 "Derived print function called."
delete b;
delete d;
return 0;
}
智能指针
后面专门说这个智能指针。
6. STL 中的一些变化
unordered_map 和 unordered_set。这两个我们前面已经进行了非常详细的讲解，其他的大家可以了解一下即可。
array
数组是直接的指针解引用，array 的设置就存在了越界的内部监查
说比较鸡肋是因为 vector<int> a(10,0)更香，甚至还能初始化
int a1[10];
array<int, 10> a2;
cout << sizeof(a1) << endl;
cout << sizeof(a2) << endl;
a1[15] = 1; // 指针的解引用
a2[15] = 1; // operator[]函数调用,内部检查
// 用这个也可以，显得array很鸡肋
vector<int> a3(10, 0);forward_list
只提供头插头删，没有提供尾插尾删，因为每次都要找尾不方便！并且insert，erase也是在结点后面插入和删除。
C++11更新真正有用的是unordered_map和unordered_set，前面都学过这里不细说了。
unordered_map 和 unordered_set 是 C++ 标准库中的两个容器，它们都是基于哈希表实现的。这两个容器提供了平均常数时间复杂度的查找、插入和删除操作，前提是哈希函数能够很好地分布元素。
unordered_map
unordered_map 是一种关联容器，它存储键值对，其中键是唯一的。它允许快速检索与每个键相关联的数据。
使用 unordered_map 的基本步骤：
- 包含头文件
<unordered_map>。 - 创建
unordered_map容器。 - 使用
insert或operator[]插入键值对。 - 使用
find或operator[]查找元素。 - 使用迭代器遍历容器。
示例：
#include <iostream>
#include <unordered_map>
int main() {
// 创建一个unordered_map，键和值都是int类型
std::unordered_map<int, int> umap;
// 插入键值对
umap.insert(std::make_pair(1, 100));
umap[2] = 200; // 使用operator[]插入，如果键不存在则创建
// 查找元素
auto search = umap.find(2);
if (search != umap.end()) {
std::cout << "Found " << search->first << " with value " << search->second << std::endl;
} else {
std::cout << "Not found" << std::endl;
}
// 遍历unordered_map
for (const auto& pair : umap) {
std::cout << pair.first << ": " << pair.second << std::endl;
}
return 0;
}
unordered_set
unordered_set 是一种集合容器，它存储唯一的元素，并且这些元素是无序的。
使用 unordered_set 的基本步骤：
- 包含头文件
<unordered_set>。 - 创建
unordered_set容器。 - 使用
insert插入元素。 - 使用
find查找元素。 - 使用迭代器遍历容器。
示例：
#include <iostream>
#include <unordered_set>
int main() {
// 创建一个unordered_set，存储int类型
std::unordered_set<int> uset;
// 插入元素
uset.insert(100);
uset.insert(200);
// 查找元素
if (uset.find(200) != uset.end()) {
std::cout << "Found 200" << std::endl;
} else {
std::cout << "Not found" << std::endl;
}
// 遍历unordered_set
for (const auto& element : uset) {
std::cout << element << std::endl;
}
return 0;
}
注意事项：
unordered_map 和 unordered_set 的性能高度依赖于哈希函数的质量和桶的数量。如果哈希函数导致许多冲突，性能可能会下降到与链表相似。是无序的unordered_map 会更新该键的值，而 unordered_set 会忽略新插入的元素，因为它只存储唯一的元素。unordered_map 和 unordered_set 通常比基于树的容器（如 map 和 set）在大多数操作上更快，因为它们提供了平均常数时间复杂度的性能。然而，在某些特定情况下，基于树的容器可能提供更好的性能，特别是当元素数量较少时。容器中的一些新方法
cbegin 和 cend 方法返回 const 迭代器等等，但实际上意义不大，因为 begin 和 end 也是可以返回 const 迭代器的，这些都是属于锦上添花的操作。新接口（4 点）
- iterators 中觉得调用迭代器的const版本和非const版本不明显，就新增下面的，不过确实很鸡肋。
2. 所有容器均支持{}列表初始化的构造函数，包括自定义的类
⭕3. 黑科技：所以容器均新增了 emplace 系列接口–>性能提升
右值引用，模板的可见参数
甚至对于 push/insert，增加了一个重载的右值引用
4.增加了移动构造和移动赋值，提高了深拷贝的效率
❓ move 是实现了常量化吗？还有关于右值引用，移动构造的知识，下篇我们将详细讲到~
作者：lvy-
