为什么下面的 C++ 程序打印 '0' 而不是 '6'？

Question

我有两个名为 FWindow 和 FFramwWindow 的类。 FFramwWindow 类继承了 FWindow。 FWindow 类包含两个构造方法。

第一个是默认构造函数，第二个包含一个 int 类型的参数。

我从 FFramwWindow 类默认构造函数中调用第二个构造函数来初始化 FWindow 类的一个名为“value”的成员变量。

但我不知道为什么它不起作用 -

class FWindow {
public:
    int value;
    FWindow() 
    {
        this->value = 0;
    }
    FWindow(int val) 
    {
        this->value = val;
    }
};

class FFramwWindow : public FWindow
{
public:
    FFramwWindow()
    {
        FWindow::FWindow(6);

        printf("value %d\n", this->value);
    }
};

int main(int argc, _TCHAR* argv[])
{
    FFramwWindow obj;

    return 0;
}

上面的代码打印-value 0

我预计它会在哪里打印 - value 6

似乎它只调用了默认的基类构造函数，而不是我明确调用的第二个。

注意：我使用的是 Visual Studio 2008

Answer 1

因为你应该在构造函数中执行以下操作：

FFramwWindow() : FWindow(6)
{
....

在您的原始代码中，您创建一个 FWindow 的本地（在构造函数范围内）对象。

Answer 2

代码

FWindow::FWindow(6);

不是调用父构造函数，而是创建FWindow的本地实例。在 C++ 中指定应该调用哪个 FWindow 构造函数的正确语法是

FFramwWindow() : FWindow(6)
{
    ...
}

如果不指定基类（和数据成员）使用的构造函数，C++ 使用默认构造函数，即

FFramwWindow()
{
    ...
}

等价于

FFramwWindow() : FWindow()
{
    ...
}

请注意，如果您有多重继承，您应该为每个基类使用构造函数，用逗号分隔它们。作为奖励信息，基本构造函数是按照继承定义中指定的顺序调用的，而不是您在构造函数中指定的顺序：

class A {
    A();
    A(int n);
    A(string s);
};

class B {
    B(int n = 6);
}

class C {
    C();
    C(float x);
}

class D: public A, public B, public C {
    D();
}

D::D() : C(3),A(5)
{
}

在本例中，创建D 的实例将依次调用A(5)、B(6)、C(3.0)、D() 的构造函数

Answer 3

在声明派生类的构造函数时，必须调用基类的构造函数。考虑这个例子：

#include<iostream>
class base
{
public:
    int i;
    base()
    {
        i = 0;
    }
    base(int p)
    {
        i = p;
    }
};

class derived1: public base
{
public:
    derived1():base()
    {
        std::cout<<i<<std::endl; //i is 0 here
    }
};

class derived2: public base
{
public:
    derived2():base(10)
    {
        std::cout<<i<<std::endl; //i is 10 here
    }
};

class derived3: public base
{
public:
    derived3(int x):base(x)
    {
        std::cout<<i<<std::endl;
        //this takes an argument from the derived class's constructor
        //as base class's constructor's parameter
    }
};

int main()
{
    derived1 d1;
    derived2 d2;
    derived3 d3(9);
    return 0;
}

在derived1 类中，调用base 类的第一个构造函数。在derived2 类中，调用了第二个构造函数。在第三种情况下，构造函数接受一个参数，该参数传递给基类的构造函数（这意味着我们使用的是基类的第二个构造函数）。

在您的代码中，您没有调用基类的构造函数，该构造函数默认调用不带参数的构造函数。这就是它输出 0 的原因。

FWindow::FWindow(6);

这个语句只是创建了一个 FWindow 类的临时新对象，它在这个语句执行后立即被销毁。构造函数意味着在创建对象时自动调用。它们不应该被手动调用。

你可以在这里找到一些解释：http://www.geeksforgeeks.org/possible-call-constructor-destructor-explicitly/