C++组合类型中默认成员初始化方法-C++-PHP中文网

C++组合类型成员的默认初始化行为取决于成员类型、类内初始化器（ICMI）和构造函数定义。基本类型成员在局部对象中若无ICMI或构造函数初始化，则为未定义值（垃圾值）；全局或静态对象及用{}初始化时会被零初始化。类类型成员优先使用ICMI，否则调用其默认构造函数，若不存在则编译失败。ICMI提供保底初始化，但构造函数初始化列表优先级更高。为避免垃圾值，应优先使用ICMI、构造函数初始化列表，并避免在构造函数体内赋值基本类型成员。

c++组合类型中默认成员初始化方法

在C++组合类型中，成员的默认初始化行为并非一成不变，它复杂地取决于成员的类型（是基本类型还是类类型）、它们是否拥有类内初始化器（ICMI），以及包含它们的类是否定义了构造函数。简单来说，基本类型成员在大多数局部语境下默认是未初始化的，而类类型成员则会尝试调用其默认构造函数，如果存在的话。C++11引入的类内成员初始化器则为所有成员提供了一个强大的“保底”初始化机制。

解决方案

理解C++组合类型（如

struct

登录后复制

或

class

登录后复制

）中成员的默认初始化，我们首先要区分几种关键情况。这不仅仅是语法问题，更是关乎程序正确性与效率的核心。

1. 基本类型成员（如

int

登录后复制

,
double
登录后复制
, 指针等）

当一个组合类型对象被默认初始化（例如，

MyStruct obj;

登录后复制

）时：

立即学习“C++免费学习笔记（深入）”；

作为局部对象成员时： 如果这些基本类型成员没有在类内定义时提供初始化器（即C++11后的ICMI），也没有在构造函数的成员初始化列表中显式初始化，那么它们的值是未定义的（uninitialized）。这意味着它们可能含有任何“垃圾”值，使用它们会导致未定义行为。
作为全局或静态存储期对象成员时： 它们会被零初始化。这是C++标准对这类变量的特殊规定，以确保程序启动时的确定性。
使用
{}
登录后复制
进行值初始化时：例如
```
MyStruct obj{};
```
登录后复制
或
```
new MyStruct{};
```
登录后复制
，即使是基本类型成员，也会被零初始化。这是一种安全地初始化基本类型成员的推荐方式。

2. 类类型成员（自定义类、

std::string

登录后复制

,
std::vector
登录后复制
等）

拥有类内成员初始化器（ICMI）时： 如果成员在类定义时就提供了初始化器（例如
```
std::string s = "hello";
```
登录后复制
或
```
std::vector<int> v{1, 2, 3};
```
登录后复制
），那么这个ICMI会优先生效。
没有ICMI，但类型拥有可访问的默认构造函数时： 编译器会调用该成员类型的默认构造函数进行初始化。如果这个默认构造函数是编译器隐式生成的，它会递归地对成员的成员进行初始化。
没有ICMI，且类型没有可访问的默认构造函数时： 编译会失败。这是因为编译器无法知道如何构造这个成员。在这种情况下，你必须在包含它的类的构造函数初始化列表中显式地初始化这个成员。

3. 类内成员初始化器 (In-class Member Initializers, ICMIs) (C++11及以后)

这是C++11引入的一项重要特性，它允许你在类定义中直接为非静态数据成员提供默认值。

优先级： ICMI的优先级低于构造函数的成员初始化列表。如果构造函数初始化列表显式初始化了某个成员，那么ICMI会被忽略。否则，ICMI就会生效。
作用： ICMI为成员提供了一个“保底”的默认值，极大地简化了构造函数的编写，并减少了因遗漏初始化而导致的未定义行为。

代码示例：

#include <iostream>
#include <string>
#include <vector>

struct MyStruct {
    int i;                  // 基本类型，无ICMI。局部对象时未初始化。
    double d = 3.14;        // 基本类型，有ICMI。
    std::string s;          // 类类型，无ICMI。调用std::string的默认构造函数。
    std::vector<int> v{1, 2, 3}; // 类类型，有ICMI。
    int arr[2];             // 基本类型数组，无ICMI。局部对象时元素未初始化。

    // 默认构造函数，没有显式初始化 i 和 arr
    MyStruct() {
        std::cout << "MyStruct default constructor called." << std::endl;
        // 注意：i 和 arr 此时仍是未定义的，除非在这里或初始化列表中显式赋值。
        // d, s, v 已经通过ICMI或其默认构造函数完成初始化。
    }

    // 带参数的构造函数，显式初始化了 i
    MyStruct(int val) : i(val) {
        std::cout << "MyStruct parameterized constructor called." << std::endl;
        // d, s, v 依然会通过ICMI或其默认构造函数初始化。
    }
};

struct AnotherStruct {
    int x = 10; // ICMI
    AnotherStruct() = default; // 编译器生成的默认构造函数会使用ICMI
};

struct YetAnotherStruct {
    int y;
    YetAnotherStruct() : y(20) {} // 构造函数初始化列表显式初始化 y
};

struct NoDefaultCtorMember {
    NoDefaultCtorMember(int val) : value(val) {} // 只有带参数的构造函数
    int value;
};

struct ContainsNoDefaultCtorMember {
    // NoDefaultCtorMember member_obj; // 编译错误：NoDefaultCtorMember没有可访问的默认构造函数
    NoDefaultCtorMember member_obj{5}; // OK，通过ICMI提供初始化参数
    ContainsNoDefaultCtorMember() {}
};

int main() {
    std::cout << "--- 默认初始化 MyStruct ms; ---" << std::endl;
    MyStruct ms; // 局部对象，i 和 arr 是未定义的
    std::cout << "ms.i: " << ms.i << std::endl; // 输出垃圾值
    std::cout << "ms.d: " << ms.d << std::endl; // 输出3.14
    std::cout << "ms.s: '" << ms.s << "'" << std::endl; // 输出空字符串
    std::cout << "ms.v size: " << ms.v.size() << std::endl; // 输出3
    std::cout << "ms.arr[0]: " << ms.arr[0] << std::endl; // 输出垃圾值

    std::cout << "\n--- 值初始化 MyStruct ms_value{}; ---" << std::endl;
    MyStruct ms_value{}; // 所有基本类型成员会被零初始化
    std::cout << "ms_value.i: " << ms_value.i << std::endl; // 输出0
    std::cout << "ms_value.d: " << ms_value.d << std::endl; // 输出3.14 (ICMI优先)
    std::cout << "ms_value.s: '" << ms_value.s << "'" << std::endl; // 输出空字符串
    std::cout << "ms_value.v size: " << ms_value.v.size() << std::endl; // 输出3
    std::cout << "ms_value.arr[0]: " << ms_value.arr[0] << std::endl; // 输出0

    std::cout << "\n--- MyStruct parameterized constructor ---" << std::endl;
    MyStruct ms_param(100);
    std::cout << "ms_param.i: " << ms_param.i << std::endl; // 输出100

    std::cout << "\n--- AnotherStruct as; ---" << std::endl;
    AnotherStruct as;
    std::cout << "as.x: " << as.x << std::endl; // 输出10

    std::cout << "\n--- YetAnotherStruct yas; ---" << std::endl;
    YetAnotherStruct yas;
    std::cout << "yas.y: " << yas.y << std::endl; // 输出20

    std::cout << "\n--- ContainsNoDefaultCtorMember cndcm; ---" << std::endl;
    ContainsNoDefaultCtorMember cndcm;
    std::cout << "cndcm.member_obj.value: " << cndcm.member_obj.value << std::endl; // 输出5

    return 0;
}

登录后复制

C++类成员变量的默认初始化，哪些情况会导致“垃圾值”？

在我看来，C++在效率与安全性之间做了权衡。对于基本类型（

int

登录后复制

float

登录后复制

, 指针等），C++默认情况下并不会强制进行零初始化，这主要是为了避免在不需要时产生额外的性能开销。这种设计哲学导致了“垃圾值”的出现，如果开发者不注意，很容易踩坑。

紫东太初

中科院和武汉AI研究院推出的新一代大模型

查看详情

具体来说，以下几种情况最容易导致成员变量含有“垃圾值”：

局部组合类型对象的基本类型成员未被显式初始化： 这是最常见的陷阱。当你声明一个局部对象，例如
```
MyStruct ms;
```
登录后复制
，如果
```
MyStruct
```
登录后复制
中的
```
int
```
登录后复制
或
```
double
```
登录后复制
成员没有在类定义中提供ICMI，也没有在
```
MyStruct
```
登录后复制
的构造函数（无论是默认构造函数还是用户定义的其他构造函数）的成员初始化列表中初始化，更没有在构造函数体内部赋值，那么这些成员的值将是未定义的。它们会保留创建时内存区域中的任意二进制数据，这就是我们常说的“垃圾值”。
```
struct BadExample {
    int value; // 没有ICMI
    // BadExample() {} // 默认构造函数没有初始化 value
};

int main() {
    BadExample be;
    std::cout << be.value << std::endl; // 极可能输出垃圾值
}
```
登录后复制
基本类型数组作为成员，且未被显式初始化： 数组的初始化规则与单个基本类型成员类似。如果一个
```
int arr[10];
```
登录后复制
作为类成员，且没有ICMI或构造函数初始化，那么
```
arr
```
登录后复制
中的每个元素都将是未定义的。
```
struct AnotherBadExample {
    int data[5]; // 没有ICMI
    // AnotherBadExample() {}
};

int main() {
    AnotherBadExample abe;
    std::cout << abe.data[0] << std::endl; // 极可能输出垃圾值
}
```
登录后复制
构造函数体内部赋值而非初始化列表： 这是一个微妙但重要的点。如果你在构造函数体内部对基本类型成员进行赋值，例如：
```
struct MyClass {
    int x;
    MyClass() {
        x = 10; // 在这里赋值
    }
};
```
登录后复制
在
```
x = 10;
```
登录后复制
执行之前，
```
x
```
登录后复制
已经经历了默认初始化阶段。对于基本类型，这意味着它首先是未定义的。虽然最终它会被赋值为10，但在赋值前的一小段时间内，它确实是未定义的。虽然这通常不会导致运行时错误，但从严格的C++语义上讲，它在构造函数体执行前确实“拥有”了垃圾值。更重要的是，对于非基本类型，这会导致先默认构造，再调用赋值运算符，效率较低且可能产生不必要的副作用。

与此形成对比的是，全局或静态存储期的对象，其所有成员（包括基本类型）都会被零初始化。而使用

{}

登录后复制

进行值初始化时，也能确保所有基本类型成员被零初始化，从而避免垃圾值。所以，理解这些细微的差别，对编写健壮的C++代码至关重要。

如何确保C++组合类型成员总是被正确初始化？

确保C++组合类型成员总是被正确初始化，是编写健壮、可维护代码的关键一步。这不仅能避免未定义行为，还能提升代码的清晰度。在我多年的开发经验中，我总结出几种行之有效的方法，它们各有侧重，但目标一致：

优先使用类内成员初始化器（ICMI） (C++11及以后) 这是我个人最推荐的方式，因为它简洁、直观，并且提供了一个“保底”的默认值。当一个新成员被添加到类中时，只需在声明处提供ICMI，就能确保所有构造函数在没有显式初始化该成员时，它也能获得一个合理的值。这大大减少了遗漏初始化的可能性。
```
class User {
public:
    std::string name = "Guest"; // ICMI for string
    int id = 0;                 // ICMI for int
    bool active = true;         // ICMI for bool

    User() = default; // 默认构造函数会使用ICMI
    User(const std::string& n, int i) : name(n), id(i) {} // 构造函数初始化列表优先
};

// User u; // name="Guest", id=0, active=true
// User u2("Alice", 123); // name="Alice", id=123, active=true
```
登录后复制
ICMI的优点在于其“就近原则”，成员的默认值与其声明紧密结合，易于理解和维护。
善用构造函数成员初始化列表 对于那些需要根据构造函数参数来初始化的成员，或者需要执行更复杂初始化逻辑的成员，构造函数成员初始化列表是最佳选择。它的优势在于：
- 效率： 成员在构造函数体执行之前就已经被初始化了，避免了先默认构造再赋值的二次操作，特别是对于类类型成员，这可以避免不必要的临时对象和赋值操作。
- 强制性： 对于没有默认构造函数的类类型成员，你必须在初始化列表中对其进行初始化，否则编译会失败。
- 常量和引用成员：
```
const
```
  登录后复制
  成员和引用成员只能在初始化列表中初始化，因为它们一旦创建就不能被赋值。
```
class Point {
const int x; // const 成员
int& y_ref;  // 引用成员
std::string label;
```
  登录后复制
public: Point(int val_x, int& val_y, const std::string& l) : x(val_x), y_ref(val_y), label(l) { // 必须使用初始化列表 // 构造函数体内部不能再对 x 和 y_ref 赋值 } };
登录后复制
避免在构造函数体内部对成员进行赋值 如前所述，在构造函数体内部对成员赋值，意味着该成员首先经历了默认初始化（对于基本类型是未定义，