Foo f = Foo(); // 没有匹配的函数调用 'Foo::Foo(Foo)' ... 嗯？

Question

class Foo
{
public:
    explicit Foo() {}
    explicit Foo(Foo&) {}
};

Foo d = Foo();

错误：没有匹配的函数调用 'Foo::Foo(Foo)'

我尝试按照错误提示将Foo(Foo&) 更改为Foo(Foo)，AFAIK 不是有效的构造函数，果然我得到了：

错误：无效的构造函数；你的意思可能是“Foo (const Foo&)”

什么给了？我该如何解决这个问题？ （顺便说一下，这是在 GCC 上）

Answer 1

您的复制构造函数中有两个值得怀疑的地方。

首先，你已经明确了复制构造函数（这是一个值得怀疑的事情），所以你（理论上）需要这样做：

Foo d( (Foo()) );

其次，您的复制构造函数采用引用而不是 const 引用，这意味着您不能将它与临时 Foo 一起使用。

就我个人而言，我会从复制构造函数中删除 explicit，并尽可能将其设为 const 引用。

请注意，默认构造函数上的explicit 无效。[*] explicit 仅对可以使用单个参数调用的构造函数有效。它可以防止它们被用于隐式转换。对于只接受零个或两个或多个参数的构造函数，它没有任何作用。

[注意：两者之间可能存在差异：

Foo d;

和

Foo d = Foo();

但在这种情况下，您有一个用户声明的默认构造函数，因此这不适用。]

编辑： [*] 我刚刚仔细检查了这一点，12.3.1 [class.conv.ctor] 说你可以创建一个默认构造函数explicit。在这种情况下，构造函数将用于执行 default-initialization 或 value-initialization。老实说，我不明白 this 的价值，就好像你有一个用户声明的构造函数，然后它是一个非 POD 类型，即使是非 POD 类型的本地对象，如果它们没有初始化器，它们也会被默认初始化该子句所说的可以通过explicit 默认构造函数来完成。也许有人可以指出它确实会产生影响的极端情况，但现在我看不出explicit 对默认构造函数有什么影响。

Answer 2

您不想将这些构造函数中的任何一个标记为显式 - 编译器需要隐式使用它们，尤其是复制构造函数。你想通过显式标记它们来达到什么目的？

Answer 3

首先，默认构造函数和复制构造函数都不应该是explicit。您只需要创建一个构造函数explicit，如果它接受某个其他类型的单个参数，以防止从该类型进行隐式转换。复制构造函数引用类本身，因此不存在不必要的转换的危险。

其次，确保复制构造函数采用const 引用。

第三，Foo f; 是拥有类 foo 的默认构造对象的正确方法。请注意Foo f(); 是错误的，因为编译器会将其解释为函数f() 的声明，它返回类Foo 的对象。

第四，如果你写了自己的拷贝构造函数，那么你也应该写赋值运算符。

class Foo { Foo() {} // no need to make explicit. Nothing to convert from. Foo(const &Foo f) {} // again, nothing wrong with conversion from Foo to Foo explicit Foo(int a) {} // need explicit to prevent accidental passing of an int // to a function that takes Foo as an argument };

Answer 4

尝试不显式？我认为：

Foo foo = Foo()

创建一个隐式副本，因此不会触发显式副本构造函数。

编辑：

这只是答案的一半。请参阅 Charles Bailey 或 UncleBens 帖子了解为什么需要 const。

Answer 5

复制构造函数不应该是显式的（这使得它在此处和许多其他完全合理的上下文中不可调用，例如在按值传递或返回时）。

接下来它应该通过 const 引用来获取参数，否则它无法绑定到临时对象。

Foo f = Foo();
        ^^^^^
          |
          --- this is a temporary that cannot be passed to a function
              that accepts a non-const reference

此外，没有理由使默认构造函数显式：这个关键字只对可以用一个参数调用的构造函数（除了复制构造函数）有意义，在这种情况下它防止通过该构造函数将其他类型隐式转换为 Foo 。例如，如果采用 int 的构造函数是 explicit，则此类情况将无法编译：

Foo f;
f = 1;  //assuming no operator= overload for (types convertible from) int
        //this implicitly performs f = Foo(1);

Foo g = 10;

void x(Foo);
x(20);

总而言之：

class Foo
{
public:
    Foo();
    Foo(const Foo&);
    //...
};

Foo x = Foo();

此外，如果这些构造函数都不打算做任何事情，你根本不需要定义它们——编译器会自动提供它们（如果你定义了任何其他构造函数，默认构造函数将不会自动生成，尽管)。

Answer 6

Foo d = Foo();

应该是

Foo d;

第一行创建一个Foo实例，然后将其复制到d；

Answer 7

您的问题在于实例化。默认构造函数不需要Foo d = Foo();。

保持你的类不变，但试试这个实例化：

Foo d;

事实上，你甚至不需要Foo d = Foo(arguments); 来构造参数。应该是这样的：

Foo d(arguments);

Answer 8

编译器告诉你...使用这个：

Foo(const Foo&) {}

Answer 9

您可以通过以下两种方式中的任何一种来解决此问题。一个（Randolpho 已经建议）是消除使用复制 ctor。另一种是写一个合适的copy ctor：

Foo (Foo const &) {}

你通常都想同时做。

编辑：看着它，我的最后一条评论很容易被误解。相当多的类根本不需要复制ctor，但是如果你确实需要一个复制ctor，它通常应该有上面的形式（不明确，并采取const 引用作为参数）。

Answer 10

class Foo
{
public:
    explicit Foo() {}
    explicit Foo(const Foo&) {}
};

Foo d = Foo()