我们是否“继承”了 C++ 中的构造函数？ “继承”的确切定义是什么

Question

我想知道为什么人们说：

“继承类不继承构造函数”。

如果可以使用父类的构造函数，无参构造函数无论如何都会自动调用。

例子：

#include <iostream>
using namespace std;

class A {
    private :
        int x;
    public  :
        A () {
            cout << "I anyway use parameter-less constructors, they are called always" << endl;
        }
        A (const int& x) {
            this->x = x;
            cout << "I can use the parent constructor" << endl;
        }
};

class B : public A {
    private :
        int y;
    public  :
        B() {

        }
        B (const int& x, const int& y) : A (x) {
            this->y = y;
        }
};

int main() {

    B* b  = new B(1,2);
    B* b1 = new B();
    return 0;
}

http://ideone.com/e.js/6jzkiP

那么“说”是否正确，构造函数是在 c++ 中继承的？编程语言中“继承”的确切定义是什么？

提前致谢。

Answer 1

我不知道为什么人们说：“继承类不继承构造函数”。

也许最好用一个例子来说明这一点：

struct Foo
{
  Foo(int, int) {}
};

struct Bar : Foo
{
};

这意味着没有可以调用的Bar::Bar(int, int) 构造函数，尽管基类中存在具有相同参数列表的构造函数。所以你不能这样做：

Bar b(42, 42);

在 C++11 中，您实际上可以继承构造函数，但您必须明确说明：

struct Bar : Foo
{
  using Foo::Foo;
};

现在，你可以说Bar b(42, 42);

Answer 2

他们的意思是构造函数签名不是继承的。

在您的示例中，B 没有采用单个 const int& 的构造函数，即使它的基类有。从这个意义上说，它并没有“继承”构造函数（但仍然可以使用它）。

Answer 3

我认为他们的意思是：

struct A {
    A(int, int) { }
};

struct B : public A {
};

int main()
{
    A a(1, 2); // ok
    B b(1, 2); // error
}

与“非特殊”成员函数进行比较：

struct A {
    void f() { }
};

struct B : public A {
};

int main()
{
    A a;
    B b;
    a.f(); // ok
    b.f(); // ok too
}

当然，您可以从B 中调用可访问的A 构造函数（就像自动生成的构造函数一样）。析构函数也是如此。

---

请注意，在 C++11 中，您可以使用“继承构造函数”功能：

struct A {
    A(int, int) { }
};

struct B : public A {
    using A::A;
};

int main()
{
    A a(1, 2); // ok
    B b(1, 2); // ok now
}

Answer 4

为了保持一致性，派生类可以/必须看到基类构造函数才能调用它们。但是，它们的签名没有暴露在派生类中，因此，如果没有明确定义的构造函数，就无法构造类，该构造函数将所需的参数转发给基类构造函数。

在 C++11 中，一个可以继承构造函数：What is constructor inheritance?

在 C++ 中绕过“代理构造函数”的另一种方法How to define different types for the same class in C++

Answer 5

在您的示例中，B 的默认（“无参数”）构造函数确实调用了 A 的默认构造函数，但这并不意味着 B“继承”了该构造函数，只是它“有权访问”它.也就是说，A 的默认构造函数可以从 B 内部访问，但不能从外部访问（没有人可以从外部使用 A 的默认构造函数来构造 B 的实例）。

另一种看待它的方式是问，C++ 中的构造函数和继承有什么令人沮丧的地方？一些人（包括我自己）的常见回答是，没有自动工具允许“传递”构造基类，从派生类构造函数中获取参数，而无需显式声明和定义后者。