使用带或不带初始值设定项列表的默认构造函数作为类数据成员的对象

Question

对于以下程序，

#include <iostream>
using namespace std;

class university{
private:
    string uni;
public:
    university(){
        cout<<"default constructor of university is invoked"<<endl;
    }
    university(string u){
        uni =u;
        cout<<"parametrized constructor of university is invoked: "<<uni;
    }
};

class student{
private:
    university u;
public:
    student() {
        u = university("ABC");
    }
};

int main()
{
    student s;

    return 0;
}

输出为：

default constructor of university is invoked
parametrized constructor of university is invoked: ABC

但是当更改学生类的构造函数以使用初始化列表时，如下所示：

    student(): u(university("ABC")){

    }

输出为：

parametrized constructor of university is invoked: ABC

我的问题是： 对于第二种情况，当编译器在student类的私有部分运行行university u时，它是否创建类'university'的对象'u'并为其分配内存地址，或者对象是否在初始化列表中创建？如果是前者，那么为什么它不调用默认构造函数？

对于第一种情况，我有同样的问题在哪里创建对象并分配内存位置。

Answer 1

“分配内存”和“分配内存位置”与这里无关。您询问的是如何构造属于另一个类的成员的对象。试图在这里引入内存分配的主题只会让事情变得混乱。高级 C++ 技术允许“在同一位置”重复构造和销毁对象（通过放置 new 和显式析构函数调用）。实际的内存位置和对象构造/销毁完全无关紧要。它们彼此无关，如果您忘记有关内存位置的所有内容，只关注对象构造和销毁的主题，将会很有帮助。话虽如此：

对象构造函数负责构造对象的所有成员。这就是规则。没有例外。句号。

student(): u(university("ABC")){

这会起作用，但是这也会在一个令人困惑的成员中实现这一点。这说明了以下事件序列：构造一个临时的大学对象，然后复制构造学生类的实际成员，最后临时对象被销毁。这是没有必要的，只会把水搅浑。使用更简单的现代 C++ 语法，这应该是：

student(): u{"ABC"}{

这种更短、直接的语法以一种简单、简洁的方式准确地描述了正在发生的事情：对象的构造函数构造该对象的所有成员，即这里仅构造一个成员。它被称为u。 u 的构造函数被调用，并将字符串作为参数传递给它。大学的“参数化”构造函数被调用。构造函数的成员初始化部分只不过是一个简单的列表：这里是我的类成员，这里是它们各自构造函数的参数。阿布拉卡达布拉：它们是被建造出来的。

student() {

如果构造函数没有成员初始化部分，或者没有在初始化部分列出对象的成员，则将调用相应类成员的默认构造函数。

就是这样，这就是它的全部内容：您的类（*此处该类称为 student）具有成员，并且该类的构造函数显式初始化它们，为类成员调用相应的构造函数。如果任何类成员未在初始化部分中列出，则将调用其默认构造函数，如果类成员没有默认构造函数，则生成的代码格式错误且无法编译。

Answer 2

成员未在构造函数主体中初始化。它们在执行构造函数主体之前初始化。当你写：

class student{
private:
    university u;
public:
    student() {
        u = university("ABC");
    }
};

那么u = unisversizy("ABC");不是初始化。由于您没有为 u 成员提供初始化程序，因此它将通过调用其默认构造函数来初始化。然后，在构造函数中，university("ABC") 通过调用另一个构造函数来创建另一个对象，并将其分配给 u。

PS：在我看来，“参数化构造函数”这个术语是一个非常具有误导性的术语。教程中经常出现的“参数化构造函数”和默认构造函数之间的区别是错误的。默认构造函数是可以不带参数调用的构造函数，因此以下是默认构造函数（并且可以带参数调用）：

 struct foo {
      foo(int x = 0) {} // a default constructor
                        // is this a parametrized constructor ?!?
 };

Answer 3

情况 1

这里我们考虑以下情况：

student() {
        u = university("ABC"); //this is assignment not initialization
    }

当您写道：

student s; 

这些是上述语句的效果：

1. 类 student 的默认构造函数 student::student() 是叫。
2. 在进入/执行默认构造函数student::student()的主体之前，类<的默认构造函数university::university() code>university 被隐式调用。结果，您得到输出：

default constructor of university is invoked

3. 现在，一旦 university::university() 的主体完全执行，将执行默认 ctor student::student() 的主体 已恢复。

4. 在执行student::student()主体时遇到以下语句：

u = university("ABC");

这是一个赋值，而不是初始化。由于表达式 university("ABC")，使用 university参数化构造函数 创建了一个临时 university 对象code>，因此您会得到输出：

parametrized constructor of university is invoked: ABC

5. 上一步中创建的临时对象被分配给数据成员u。

情况 2

这里我们考虑这样的情况：

student(): u(university("ABC")){

    }

当您写道：

student s;

发生的情况是这样的：

1. 调用类 student 的默认构造函数。
2. 在进入默认构造函数 student::student() 的主体之前，参数化构造函数 university::university(std::调用类 university 的 string) 是因为您有表达式 university("ABC") 并且数据成员 u 是已初始化。请注意，由于调用了参数化 ctor，您将得到输出：

default constructor of university is invoked

3. 现在，当参数化 ctor 的主体完成时，执行类 student 的默认 ctor student::student() 的主体 恢复。

注意

在示例的情况 2 中，您应将 student():u(university("ABC")){} 更改为：

student(): u("ABC"){

    }