目录
1. 默认初始化（Default Initialization）
3. 直接初始化（Direct Initialization）
6. 聚合初始化（Aggregate Initialization）
7. 引用初始化（Reference Initialization）
8. 成员初始化列表（Member Initialization List）
9. 显式初始化（Explicit Initialization）
10. 延迟初始化（Lazy Initialization）
11. 常量初始化（Constant Initialization）
12. 静态初始化（Static Initialization）
摘要
在C++中，初始化变量的方法非常多，涵盖了多种类型的初始化方式。以下是C++中的常见初始化类型：
1. 默认初始化：未定义值或调用默认构造函数。
2. 值初始化：将变量初始化为零或调用默认构造函数。
3. 直接初始化：通过括号传递参数进行初始化。
4. 拷贝初始化：使用赋值运算符进行初始化。
5. 列表初始化：使用大括号进行初始化，避免窄化转换。
6. 聚合初始化：用于数组和 `struct` 等聚合类型的初始化。
7. 引用初始化：引用变量必须在声明时进行初始化。
8. 成员初始化列表：在类的构造函数中初始化成员变量。
9. 显式初始化：使用显式构造函数进行初始化。
10. 延迟初始化：在需要时才进行初始化。
11. 常量初始化：常量变量在编译时完成初始化。
12. 静态初始化：静态变量的初始化在程序启动时完成。
1. 默认初始化（Default Initialization）
默认初始化是指在声明变量时不提供初始值。对于内置类型变量，其值是未定义的；对于类类型变量，会调用其默认构造函数。
#include <iostream>
class MyClass {
public:
int x;
MyClass() : x(0) {
std::cout << "MyClass default constructor called\n";
}
};
int main() {
int a; // 未定义值
MyClass obj; // 调用 MyClass 的默认构造函数
std::cout << "obj.x: " << obj.x << std::endl; // 输出 0
return 0;
}
2. 值初始化（Value Initialization）
值初始化会将变量初始化为零值。对于类类型，会调用其默认构造函数。
#include <iostream>
class MyClass {
public:
int x;
MyClass() : x(0) {
std::cout << "MyClass default constructor called\n";
}
};
int main() {
int a = int(); // 初始化为 0
MyClass obj = MyClass(); // 调用 MyClass 的默认构造函数
std::cout << "a: " << a << std::endl;
std::cout << "obj.x: " << obj.x << std::endl;
return 0;
}
3. 直接初始化（Direct Initialization）
直接初始化通过括号传递参数进行初始化。
#include <iostream>
class MyClass {
public:
int x;
MyClass(int val) : x(val) {
std::cout << "MyClass(int) constructor called\n";
}
};
int main() {
MyClass obj(10); // 调用 MyClass(int) 构造函数
std::cout << "obj.x: " << obj.x << std::endl;
return 0;
}
4. 拷贝初始化（Copy Initialization）
拷贝初始化通过赋值运算符将初始值赋给变量，会调用拷贝构造函数或移动构造函数。
#include <iostream>
class MyClass {
public:
int x;
MyClass(int val) : x(val) {
std::cout << "MyClass(int) constructor called\n";
}
MyClass(const MyClass& other) : x(other.x) {
std::cout << "MyClass copy constructor called\n";
}
};
int main() {
MyClass obj1(10); // 调用 MyClass(int) 构造函数
MyClass obj2 = obj1; // 调用拷贝构造函数
std::cout << "obj1.x: " << obj1.x << std::endl;
std::cout << "obj2.x: " << obj2.x << std::endl;
return 0;
}
5. 列表初始化（List Initialization）
C++11引入了列表初始化，使用大括号 `{}` 进行初始化，可以避免窄化转换，并支持统一的初始化方式。
#include <iostream>
class MyClass {
public:
int x;
MyClass(int val) : x(val) {
std::cout << "MyClass(int) constructor called\n";
}
};
int main() {
MyClass obj1{10}; // 调用 MyClass(int) 构造函数
int a{5}; // 初始化为 5
std::cout << "obj1.x: " << obj1.x << std::endl;
std::cout << "a: " << a << std::endl;
return 0;
}
6. 聚合初始化（Aggregate Initialization）
用于聚合类型（如数组和 `struct`），直接使用大括号 `{}` 为成员变量赋值。
#include <iostream>
struct MyStruct {
int a;
float b;
};
int main() {
MyStruct s1 = {1, 2.5f}; // 聚合初始化
int arr[3] = {1, 2, 3}; // 数组的聚合初始化
std::cout << "s1.a: " << s1.a << ", s1.b: " << s1.b << std::endl;
std::cout << "arr: " << arr[0] << ", " << arr[1] << ", " << arr[2] << std::endl;
return 0;
}
7. 引用初始化（Reference Initialization）
引用变量必须在声明时进行初始化，且引用类型的初始化方式与其引用对象一致。
#include <iostream>
int main() {
int x = 10;
int& ref = x; // 引用初始化
std::cout << "ref: " << ref << std::endl;
ref = 20;
std::cout << "x: " << x << std::endl; // x 也会改变
return 0;
}
8. 成员初始化列表（Member Initialization List）
用于在类的构造函数中初始化成员变量。
#include <iostream>
class MyClass {
public:
int x;
int y;
MyClass(int a, int b) : x(a), y(b) {
std::cout << "MyClass(int, int) constructor called\n";
}
};
int main() {
MyClass obj(10, 20); // 使用成员初始化列表
std::cout << "obj.x: " << obj.x << ", obj.y: " << obj.y << std::endl;
return 0;
}
9. 显式初始化（Explicit Initialization）
使用显式构造函数进行初始化。防止隐式转换。
#include <iostream>
class MyClass {
public:
int x;
explicit MyClass(int val) : x(val) {
std::cout << "MyClass(int) constructor called\n";
}
};
int main() {
MyClass obj1(10); // 直接初始化
// MyClass obj2 = 10; // 错误：不能进行隐式转换
std::cout << "obj1.x: " << obj1.x << std::endl;
return 0;
}
10. 延迟初始化（Lazy Initialization）
延迟初始化是指在需要时才进行初始化，常用于优化性能，减少资源占用。
#include <iostream>
#include <memory>
class MyClass {
public:
MyClass() {
std::cout << "MyClass constructor called\n";
}
void doSomething() {
std::cout << "Doing something\n";
}
};
int main() {
std::unique_ptr<MyClass> ptr; // 声明但不初始化
// ...
if (!ptr) {
ptr = std::make_unique<MyClass>(); // 在需要时初始化
}
ptr->doSomething();
return 0;
}
11. 常量初始化（Constant Initialization）
常量初始化用于初始化 `const` 变量，在编译时完成。
#include <iostream>
const int a = 10; // 常量初始化
int main() {
std::cout << "a: " << a << std::endl;
return 0;
}
12. 静态初始化（Static Initialization）
静态变量的初始化，分为零初始化和常量初始化，在程序启动时完成。
#include <iostream>
class MyClass {
public:
static int count;
static const int constant;
};
int MyClass::count = 0; // 静态初始化
const int MyClass::constant = 42; // 常量初始化
int main() {
std::cout << "MyClass::count: " << MyClass::count << std::endl;
std::cout << "MyClass::constant: " << MyClass::constant << std::endl;
return 0;
}