我不明白为什么这个程序的输出是这样的。为什么没有编译错误？我以为在尝试构造 B 时，编译器会找不到名为 foo() 的函数并报告错误。

#include <iostream>
using namespace std;

struct A{
    int a;
    A(int i=0) : a(i) { cout << "A" << endl; }
    ~A() { cout << "Bye A" << endl; }
    int foo() { return a; }
};
struct B{
    int b;
    B(int i=0) : b(i) { cout << "B" << endl; }
    ~B() { cout << "Bye B" << endl; }
    int bar() { return b; }
};
struct C : B, A {
    C(int i=0) : B(foo()), A(i) {}
};

int main() {
    cout << C(10).bar() << endl;
    return 0;
}

输出:

B
A
0
Bye A
Bye B

一般来说，我想知道当存在多重继承时，父结构体的构造和初始化顺序是怎样的？我也可以在类里面期待类似的行为吗？

非常感谢任何关于构造函数和析构函数调用顺序的解释。

注意:这不是家庭作业。而且，我研究过类似的主题，但没有找到关于这个问题的答案。

最佳答案

未定义的行为

您通过调用 foo 调用了未定义的行为在对象完全初始化之前。引用 C++ 标准中的 12.6.2 :

Member functions (including virtual member functions, 10.3) can be called for an object under construction. Similarly, an object under construction can be the operand of the typeid operator (5.2.8) or of a dynamic_cast (5.2.7). However, if these operations are performed in a ctor-initializer (or in a function called directly or indirectly from a ctor-initializer) before all the mem-initializers for base classes have completed, the result of the operation is undefined. [ Example:

class A {
public:
  A(int);
};

class B : public A {
  int j;
public:
  int f();
  B() : A(f()),       // undefined: calls member function
                      // but base A not yet initialized
          j(f()) { }  // well-defined: bases are all initialized
};

class C {
public:
  C(int);
};

class D : public B, C {
  int i;
public:
  D() : C(f()),       // undefined: calls member function
                      // but base C not yet initialized
          i(f()) { }  // well-defined: bases are all initialized
};

— end example ]

换句话说，根据标准，这是可以的:

C(int i=0) : B(), A(i) {
    B::b = foo();
}

这将打印 10而不是 0你得到的(可能是其他任何东西，因为那是未定义的行为)。

初始化顺序

抛开未定义行为这个问题，为了解决您的问题，初始化发生的顺序是明确定义的:

In a non-delegating constructor, initialization proceeds in the following order:

— First, and only for the constructor of the most derived class (1.8), virtual base classes are initialized in the order they appear on a depth-first left-to-right traversal of the directed acyclic graph of base classes, where “left-to-right” is the order of appearance of the base classes in the derived class base-specifier-list.

— Then, direct base classes are initialized in declaration order as they appear in the base-specifier-list (regardless of the order of the mem-initializers).

— Then, non-static data members are initialized in the order they were declared in the class definition (again regardless of the order of the mem-initializers).

— Finally, the compound-statement of the constructor body is executed.

[ Note: The declaration order is mandated to ensure that base and member subobjects are destroyed in the reverse order of initialization. — end note ]

因此，在您的代码中，初始化顺序是:B ( B::b ), A ( A::a ), C ().

不过，正如下面的评论所述，更改此初始化顺序(例如，使用 struct C : A, B 而不是 struct C : B, A )不会消除未定义的行为。打电话A::foo在 B 之前即使 A 部分被初始化仍未定义部分已初始化。

关于c++ - 关于结构构造函数和析构函数行为 - C++，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/41853440/