C++ 初始化大全
C++ 变量初始化方式详解
1. 基本数据类型（如 int、float、double、char 等）
1.1 直接初始化
通过赋值符号初始化：
int a = 10; // 使用赋值符号初始化
float b = 3.14f; // 使用赋值符号初始化
double c = 2.718; // 使用赋值符号初始化
char d = 'A'; // 使用赋值符号初始化
1.2 圆括号初始化
通过构造函数风格的圆括号初始化：
int a(10); // 使用圆括号初始化
float b(3.14f); // 使用圆括号初始化
double c(2.718); // 使用圆括号初始化
char d('A'); // 使用圆括号初始化
1.3 花括号初始化（C++11 及以上）
统一初始化语法，更安全：
int a{10}; // 使用花括号初始化
float b{3.14f}; // 使用花括号初始化
double c{2.718}; // 使用花括号初始化
char d{'A'}; // 使用花括号初始化
1.4 默认初始化
未显式初始化时的行为：
- 全局变量/静态变量：初始化为
0。 - 局部变量：未定义（垃圾值）。
int global_var; // 全局变量，默认初始化为 0
static int static_var; // 静态变量，默认初始化为 0void func() {int local_var; // 局部变量，未初始化，值是未定义的
}
2. 复合数据类型（如 std::string、std::vector 等）
2.1 直接初始化
std::string str = "Hello"; // 使用赋值符号初始化
std::vector<int> vec = {1, 2, 3}; // 使用赋值符号和列表初始化
2.2 圆括号初始化
std::string str("Hello"); // 使用圆括号初始化
std::vector<int> vec(3, 10); // 创建包含 3 个 10 的向量
2.3 花括号初始化
std::string str{"Hello"}; // 使用花括号初始化
std::vector<int> vec{1, 2, 3}; // 使用花括号初始化
2.4 默认初始化
调用默认构造函数：
std::string str; // 默认初始化为空字符串
std::vector<int> vec; // 默认初始化为空向量
3. 自定义数据类型（类和结构体）
3.1 直接初始化
class MyClass {
public:int x;MyClass(int val) : x(val) {} // 构造函数
};
MyClass obj = MyClass(10); // 使用赋值符号和构造函数初始化
3.2 圆括号初始化
MyClass obj(10); // 使用圆括号和构造函数初始化
3.3 花括号初始化
MyClass obj{10}; // 使用花括号和构造函数初始化
3.4 默认初始化
调用默认构造函数：
class MyClass {
public:int x;MyClass() : x(0) {} // 默认构造函数
};
MyClass obj; // 默认初始化，调用默认构造函数
4. 数组
4.1 直接初始化
int arr[] = {1, 2, 3, 4}; // 使用赋值符号和列表初始化
4.2 花括号初始化
int arr[]{1, 2, 3, 4}; // 使用花括号初始化
4.3 默认初始化
- 全局/静态数组：所有元素初始化为
0。 - 局部数组：未初始化（垃圾值）。
int global_arr[5]; // 全局数组，默认初始化为 0
static int static_arr[5]; // 静态数组，默认初始化为 0void func() {int local_arr[5]; // 局部数组，未初始化
}
5. 指针
5.1 直接初始化
int* ptr = nullptr; // 初始化为 nullptr
int* ptr = &a; // 初始化为变量地址
5.2 圆括号初始化
int* ptr(nullptr); // 使用圆括号初始化
int* ptr(&a); // 使用圆括号初始化
5.3 花括号初始化
int* ptr{nullptr}; // 使用花括号初始化
int* ptr{&a}; // 使用花括号初始化
5.4 默认初始化
未显式初始化时为未定义值：
int* ptr; // 未初始化，值是未定义的
6. 枚举类型
6.1 直接初始化
enum Color { RED, GREEN, BLUE };
Color color = RED; // 使用赋值符号初始化
6.2 圆括号初始化
Color color(RED); // 使用圆括号初始化
6.3 花括号初始化
Color color{RED}; // 使用花括号初始化
6.4 默认初始化
未显式初始化时为未定义值：
Color color; // 未初始化，值是未定义的
7. 联合体（Union）
7.1 直接初始化
union Data {int i;float f;char str[20];
} data = {10}; // 初始化第一个成员
7.2 花括号初始化
union Data {int i;float f;char str[20];
} data{10}; // 初始化第一个成员
7.3 默认初始化
未显式初始化时，第一个成员的值是未定义的：
union Data data; // 未初始化，第一个成员的值是未定义的
8. 结构体（Struct）
8.1 直接初始化
struct Point {int x, y;
} p = {10, 20}; // 使用赋值符号和列表初始化
8.2 花括号初始化
struct Point {int x, y;
} p{10, 20}; // 使用花括号初始化
8.3 默认初始化
调用默认构造函数：
struct Point {int x, y;Point() : x(0), y(0) {} // 默认构造函数
};
Point p; // 默认初始化，调用默认构造函数
9. 初始化列表（C++11 及以上）
使用花括号 {} 初始化对象：
int arr[]{1, 2, 3, 4}; // 数组
std::vector<int> vec{1, 2, 3, 4}; // 标准库容器
std::pair<int, double> p{10, 3.14}; // 标准库 pair
std::map<int, std::string> m{{1, "one"}, {2, "two"}}; // 标准库 map
10. 统一初始化（C++11 及以上）
使用 {} 初始化所有类型：
int a{10}; // 基本数据类型
std::string str{"Hello"}; // 标准库类型
std::vector<int> vec{1,2,3}; // 容器
MyClass obj{10}; // 自定义类
优点：
- 类型安全（禁止隐式窄化转换）。
- 语法一致性。
- 简洁性。
注意事项：
- 类有显式构造函数时不能使用。
- 空列表会调用默认构造函数。
11. 值初始化
显式初始化为默认值：
int a{}; // 初始化为 0
float b{}; // 初始化为 0.0f
std::string str{}; // 调用默认构造函数
12. 零初始化
显式初始化为 0：
int global_var = 0; // 全局变量显式初始化为 0
static int static_var = 0; // 静态变量显式初始化为 0
13. 聚合初始化（C++11 及以上）
初始化聚合类型（无构造函数、公有成员）：
struct Point {int x, y;
};
Point p{10, 20}; // 聚合初始化
14. 委托构造函数（C++11 及以上）
构造函数调用其他构造函数：
class MyClass {
public:MyClass(int val) : x(val) {} // 主构造函数MyClass() : MyClass(0) {} // 委托构造函数
private:int x;
};
总结
| 初始化方式 | 语法示例 | 适用场景 |
|---|---|---|
| 直接初始化 | int a = 10; | 简单类型显式赋值 |
| 圆括号初始化 | int a(10); | 显式调用构造函数 |
| 花括号初始化 | int a{10}; | 类型安全、统一语法 |
| 默认初始化 | int a; | 全局/静态变量（初始化为 0） |
| 值初始化 | int a{}; | 显式初始化为默认值 |
| 聚合初始化 | Point p{10, 20}; | 无构造函数的聚合类型 |
| 委托构造函数 | MyClass() : MyClass(0){} | 简化构造函数逻辑 |