如果我不明确地初始化类成员，如何初始化？

Question

假设我有一个带有私有成员 ptr、name、pname、rname、crname 和<代码>年龄。如果我不自己初始化它们会发生什么？这是一个例子：

class Example {
    private:
        int *ptr;
        string name;
        string *pname;
        string &rname;
        const string &crname;
        int age;

    public:
        Example() {}
};

然后我这样做：

int main() {
    Example ex;
}

成员是如何在 ex 中初始化的？指针会发生什么？ string 和 int 使用默认构造函数 string() 和 int() 是否会初始化为 0？参考会员呢？还有 const 引用呢？

我想学习它，这样我就可以编写更好的（无错误）程序。任何反馈都会有所帮助！

Answer 1

类中成员的初始化与函数中局部变量的初始化的工作方式相同，而不是显式初始化。

对于对象，将调用它们的默认构造函数。例如，对于 std::string，默认构造函数将其设置为空字符串。如果对象的类没有默认构造函数，那么如果不显式初始化它，将会出现编译错误。

对于原始类型（指针、整数等），它们未初始化——它们包含先前发生在该内存位置的任意垃圾。

对于引用（例如std::string&），不初始化它们是非法的，你的编译器会抱怨并拒绝编译这样的代码。引用必须始终被初始化。

因此，在您的具体情况下，如果它们没有显式初始化：

    int *ptr;  // Contains junk
    string name;  // Empty string
    string *pname;  // Contains junk
    string &rname;  // Compile error
    const string &crname;  // Compile error
    int age;  // Contains junk

Answer 2

首先，让我解释一下什么是mem-initializer-list。 mem-initializer-list 是一个以逗号分隔的 mem-initializer 列表，其中每个 mem-initializer 是一个成员名称，后跟(，后跟 表达式列表，后跟 )。 表达式列表是成员的构造方式。例如，在

static const char s_str[] = "bodacydo";
class Example
{
private:
    int *ptr;
    string name;
    string *pname;
    string &rname;
    const string &crname;
    int age;

public:
    Example()
        : name(s_str, s_str + 8), rname(name), crname(name), age(-4)
    {
    }
};

用户提供的无参数构造函数的 mem-initializer-list 中，为 name(s_str, s_str + 8), rname(name), crname(name),年龄（-4）。这个mem-initializer-list意味着name成员由采用两个输入迭代器的 std::string 构造函数，rname 成员通过对 的引用进行初始化name，crname 成员使用对 name 的 const 引用进行初始化，age 成员使用值<代码>-4。

每个构造函数都有自己的mem-initializer-list，并且成员只能按照规定的顺序（基本上是在类中声明成员的顺序）进行初始化。因此，Example的成员只能按照以下顺序初始化：ptr, name, pname, rname、crname 和 age。

当您不指定成员的mem-initializer时，C++标准表示：

如果实体是类类型的非静态数据成员...，则实体默认初始化 (8.5)。 ...否则，实体未初始化。

在这里，由于 name 是类类型的非静态数据成员，因此如果在 mem-initializer-list中未指定 name 的初始值设定项，则它会默认初始化。 /em>。 Example 的所有其他成员都没有类类型，因此它们未初始化。

当标准说它们未初始化时，这意味着它们可以具有任何值。因此，因为上面的代码没有初始化pname，所以它可以是任何东西。

请注意，您仍然必须遵循其他规则，例如引用必须始终初始化的规则。不初始化引用是一个编译器错误。

Answer 3

您还可以在声明数据成员时初始化它们：

class another_example{
public:
    another_example();
    ~another_example();
private:
    int m_iInteger=10;
    double m_dDouble=10.765;
};

我几乎专门使用这种形式，尽管我读过一些人认为它是“不好的形式”，也许是因为它最近才被引入 - 我认为是在 C++11 中。对我来说，这更符合逻辑。

新规则的另一个有用的方面是如何初始化本身就是类的数据成员。例如，假设 CDynamicString 是一个封装字符串处理的类。它有一个构造函数，允许您指定其初始值CDynamicString(wchat_t* pstrInitialString)。您很可能将此类用作另一个类中的数据成员 - 例如封装 Windows 注册表值的类，在本例中该类存储邮政地址。要“硬编码”要写入的注册表项名称，请使用大括号：

class Registry_Entry{
public:
    Registry_Entry();
    ~Registry_Entry();
    Commit();//Writes data to registry.
    Retrieve();//Reads data from registry;
private:
    CDynamicString m_cKeyName{L"Postal Address"};
    CDynamicString m_cAddress;
};

请注意，保存实际邮政地址的第二个字符串类没有初始值设定项，因此将在创建时调用其默认构造函数 - 可能会自动将其设置为空白细绳。

Answer 4

如果示例类在堆栈上实例化，则未初始化的标量成员的内容是随机且未定义的。

对于全局实例，未初始化的标量成员将被清零。

对于本身就是类实例的成员，将调用它们的默认构造函数，因此您的字符串对象将被初始化。

• int *ptr; //未初始化的指针（如果全局则归零）
• string name; //调用构造函数，用空字符串初始化
• string *pname; //未初始化的指针（如果全局则归零）
• string &rname; //如果未能初始化此
• const string &crname; //编译错误如果未能初始化此
• int Age; //标量值，未初始化且随机（如果全局则归零）

Answer 5

这取决于类的构造方式

回答这个问题需要理解 C++ 语言标准中的一个巨大的 switch case 语句，而对于普通人来说很难有直觉。

举一个简单的例子来说明事情有多困难：

main.cpp

#include <cassert>

int main() {
    struct C { int i; };

    // This syntax is called "default initialization"
    C a;
    // i undefined

    // This syntax is called "value initialization"
    C b{};
    assert(b.i == 0);
}

在默认初始化中，您将从以下位置开始： https://en.cppreference.com/w/cpp/language/default_initialization 我们转到“默认初始化的效果是”部分并开始 case 语句：

• “if T is a 非POD”：否（POD的定义本身就是一个巨大的开关语句）
• “如果 T 是数组类型”：否
• “否则，什么也不做”：因此它留下了一个未定义的值

然后，如果有人决定值初始化，我们会转到 https://en.cppreference.com/w/cpp/language/value_initialization “值初始化的效果是”并启动case 语句：

• “如果 T 是没有默认构造函数或具有用户提供或删除的默认构造函数的类类型”：情况并非如此。您现在将花 20 分钟谷歌搜索这些术语：
  • 我们有一个隐式定义的默认构造函数（特别是因为没有定义其他构造函数）
  • 它不是用户提供的（隐式定义的）
  • 未删除（=删除）
• “如果 T 是具有既不是用户提供也不是删除的默认构造函数的类类型”：是
  • “该对象是零初始化的，然后如果它有一个非平凡的默认构造函数，则它是默认初始化的”：没有非平凡的构造函数，只是零初始化。 “零初始化”的定义至少很简单并且符合您的期望： https:// /en.cppreference.com/w/cpp/language/zero_initialization

这就是为什么我强烈建议您永远不要依赖“隐式”零初始化。除非有强有力的性能原因，否则请显式初始化所有内容，无论是在构造函数上（如果您定义了），还是使用聚合初始化。否则，你会给未来的开发人员带来非常非常大的风险。

Answer 6

未初始化的非静态成员将包含随机数据。实际上，它们只会具有分配给它们的内存位置的值。

当然，对于对象参数（如string），对象的构造函数可以进行默认初始化。

在你的例子中：

int *ptr; // will point to a random memory location
string name; // empty string (due to string's default costructor)
string *pname; // will point to a random memory location
string &rname; // it would't compile
const string &crname; // it would't compile
int age; // random value

Answer 7

具有构造函数的成员将调用其默认构造函数进行初始化。

您不能依赖其他类型的内容。

Answer 8

如果它在堆栈上，则没有自己的构造函数的未初始化成员的内容将是随机且未定义的。即使它是全球性的，依赖它们被归零也是一个坏主意。无论它是否在堆栈上，如果一个成员有自己的构造函数，就会调用它来初始化它。

因此，如果您有 string* pname，则指针将包含随机垃圾。但对于字符串名称，将调用字符串的默认构造函数，为您提供一个空字符串。对于您的引用类型变量，我不确定，但它可能是对某些随机内存块的引用。