C++中常见的初始化类型

目录

摘要

1. 默认初始化（Default Initialization）

2. 值初始化（Value Initialization）

3. 直接初始化（Direct Initialization）

4. 拷贝初始化（Copy Initialization）

5. 列表初始化（List 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;
}

引用

Initialization - cppreference.com