构造函数混乱

Question

我一直认为我对 C++ 非常了解，但有时即使是最基本的事情我也会感到惊讶。

在以下场景中，我对为什么调用构造函数 Derived::Derived(const Base&) 感到困惑：

class Base
{ };

class Derived : public Base
{
    public:

    Derived() { }

    Derived(const Base& b) 
    {
        std::cout << "Called Derived::Derived(const Base& b)" << std::endl;
    }
};

int main()
{
    Derived d;
    Base b;
    d = b;
}

此输出： Called Derived::Derived(const Base& b)，表示调用了Derived中的第二个构造函数。现在，我认为我非常了解 C++，但我不明白为什么会调用该构造函数。我理解整个“四规则”概念，并且我认为表达式 d = b 会执行以下两件事之一：要么 1）调用隐式（编译器生成的）赋值运算符Base，或 2) 触发编译器错误，抱怨函数 Derived&运算符 = (const Base&) 不存在。

相反，它调用构造函数，即使表达式d = b 是一个赋值表达式。

那么为什么会发生这种情况呢？

Answer 1

d = b 可能发生，因为 b 已转换为 Derived。
第二个构造函数用于自动类型转换。
就像 d = (Derived) b

Derived 是 Base，但 Base 不是 Derived，因此必须在赋值之前进行转换。

Answer 2

将基数分配给派生？也许你的意思是（a）通过ref（b）或派生到基础。这实际上没有意义，但编译器正确地使用您的（非显式）构造函数将 Base 实例转换为新的 Derived 实例（随后分配给 d ）。

使用显式构造函数来防止这种情况自动发生。

就我个人而言，我认为你弄乱了你的代码示例，因为，通常将一等基分配给派生在没有转换的情况下是没有意义的

Answer 3

这里有两个相互作用的功能：

• 赋值运算符永远不会被继承
• 不显式的构造函数，或者转换运算符（运算符 T()）定义可以隐式用作一部分的用户转换转换序列的

赋值运算符永远不会被继承

一个简单的代码示例：

struct Base {}; // implicitly declares operator=(Base const&);
struct Derived: Base {}; // implicitly declares operator=(Derived const&);

int main() {
  Derived d;
  Base b;
  d = b; // fails
}

来自ideone：

prog.cpp: In function ‘int main()’:
prog.cpp:7: error: no match for ‘operator=’ in ‘d = b’
prog.cpp:2: note: candidates are: Derived& Derived::operator=(const Derived&)

< 每当存在“阻抗”不匹配

时，例如这里：

• Derived::operator= 需要一个 Derived const& 参数
• 提供了 Base& ，

编译器将尝试建立一个转换序列来弥补差距。这样的转换序列可以包含至多最多一个用户定义的转换。

在这里，它将查找：

• 可以使用 Base&（非显式）调用的任何 Derived 构造函数
• Base 中的转换运算符会产生一个 Derived 项

没有 Base::operator Derived() 但有一个 Derived::Derived(Base const&) 构造函数。

因此，我们的转换序列是为我们定义的：

• Base&
• Base const& (trivial)
• Derived （使用 Derived::Derived(Base const&))
• Derived const& （绑定到 const 引用的临时对象）

，然后调用 Derived::operator(Derived const&) 。

实际操作

如果我们用更多的跟踪来扩充代码，我们就可以看到它的实际操作 。

#include <iostream>

struct Base {}; // implicitly declares Base& operator(Base const&);
struct Derived: Base {
  Derived() {}
  Derived(Base const&) { std::cout << "Derived::Derived(Base const&)\n"; }
  Derived& operator=(Derived const&) {
    std::cout << "Derived::operator=(Derived const&)\n";
    return *this;
  }
};

int main() {
  Derived d;
  Base b;
  d = b;
}

哪些输出：

Derived::Derived(Base const&)
Derived::operator=(Derived const&)

注意：防止这种情况？

在 C++ 中，可以删除用于转换序列的构造函数。为此，需要使用 explicit 关键字在构造函数的声明前面添加前缀。

在 C++0x 中，也可以在转换运算符（运算符 T()）上使用此关键字。

如果我们在 Derived::Derived(Base const&) 之前使用 explicit，那么代码就会变得格式错误，应该被编译器拒绝。

Answer 4

由于您已经为 Derived 定义了一个采用 Base 类型的构造函数，并且您正在向下转换 Base，因此编译器会为向上转换选择最合适的构造函数，在本例中是您定义的 Derived(const Base& b)。如果您没有定义此构造函数，那么在尝试进行分配时实际上会出现编译错误。有关详细信息，您可以阅读以下内容：Linuxtopia。

Answer 5

它不能分配不同类型的值，因此它应该首先构造一个 Derived 临时值。