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; // 静态变量，默认初始化为 0

void 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]; // 静态数组，默认初始化为 0

void 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){}	简化构造函数逻辑