c++ - 删除了默认构造函数。仍然可以创建对象......有时

Question

对c++11统一初始化语法的幼稚、乐观和哦..如此错误的看法

我认为，由于 C++11 用户定义类型对象应该使用新的 {...} 语法而不是旧的 (...) 语法(为 std::initializer_list 和类似参数重载的构造函数除外(例如 std::vector:size ctor vs 1 elem init_list ctor))。

好处是:没有狭窄的隐式转换，最令人烦恼的解析、一致性(？)没有问题。我没有发现任何问题，因为我认为它们是相同的(给出的示例除外)。

但他们不是。

一个纯粹疯狂的故事

{} 调用默认构造函数。

...除非:

• 删除默认构造函数
• 没有定义其他构造函数。

那么看起来它更像是值初始化对象？...即使对象删除了默认构造函数，{} 也可以创建一个对象。这不是违背了删除构造函数的全部目的吗？

...除非:

• 该对象有一个删除的默认构造函数和
• 定义了其他构造函数。

然后它失败，调用已删除的构造函数。

...除非:

• 该对象有一个删除的构造函数和
• 没有定义其他构造函数并且
• 至少是一个非静态数据成员。

然后它因缺少字段初始值设定项而失败。

但是您可以使用 {value} 来构造对象。

好吧，也许这与第一个异常(值初始化对象)相同

...除非:

• 该类有一个已删除的构造函数
• 并且至少一个类内的数据成员被默认初始化。

那么 {} 和 {value} 都不能创建对象。

我确定我错过了一些。具有讽刺意味的是，它被称为统一初始化语法。我再说一遍:UNIFORM初始化语法。

这是什么疯狂？

场景A

删除默认构造函数:

struct foo {
  foo() = delete;
};

// All bellow OK (no errors, no warnings)
foo f = foo{};
foo f = {};
foo f{}; // will use only this from now on.

场景B

删除默认构造函数，删除其他构造函数

struct foo {
  foo() = delete;
  foo(int) = delete;
};

foo f{}; // OK

场景C

删除默认构造函数，定义其他构造函数

struct foo {
  foo() = delete;
  foo(int) {};
};

foo f{}; // error call to deleted constructor

场景D

删除了默认构造函数，没有定义其他构造函数，数据成员

struct foo {
  int a;
  foo() = delete;
};

foo f{}; // error use of deleted function foo::foo()
foo f{3}; // OK

场景E

删除默认构造函数，删除T构造函数，T数据成员

struct foo {
  int a;
  foo() = delete;
  foo(int) = delete;
};

foo f{}; // ERROR: missing initializer
foo f{3}; // OK

场景F

删除了默认构造函数，类内数据成员初始化器

struct foo {
  int a = 3;
  foo() = delete;
};

/* Fa */ foo f{}; // ERROR: use of deleted function `foo::foo()`
/* Fb */ foo f{3}; // ERROR: no matching function to call `foo::foo(init list)`

Answer 1

当以这种方式查看事物时，很容易说对象的初始化方式完全困惑。

最大的区别在于 foo 的类型:它是否是聚合类型。

It is an aggregate if it has:

• no user-provided constructors (a deleted or defaulted function does not count as user-provided),
• no private or protected non-static data members,
• no brace-or-equal-initializers for non-static data members (since c++11 until (reverted in) c++14)
• no base classes,
• no virtual member functions.

所以:

• 在场景 A B D E 中:foo 是一个聚合
• 在场景 C 中:foo 不是聚合
• 场景 F:
  • 在 c++11 中它不是聚合。
  • 在 c++14 中它是一个集合。
  • g++ 尚未实现此功能，即使在 C++14 中仍将其视为非聚合。
    • 4.9 没有实现这个。
    • 5.2.0 可以
    • 5.2.1 ubuntu 没有(可能是回归)

The effects of list initialization of an object of type T are:

• ...
• If T is an aggregate type, aggregate initialization is performed. This takes care of scenarios A B D E (and F in C++14)
• Otherwise the constructors of T are considered in two phases:
  • All constructors that take std::initializer_list ...
  • otherwise [...] all constructors of T participate in overload resolution [...] This takes care of C (and F in C++11)
• ...

:

Aggregate initialization of an object of type T (scenarios A B D E (F c++14)):

• Each non-static class member, in order appearance in the class definition, is copy-initialized from the corresponding clause of the initializer list. (array reference omitted)

---

长话短说

所有这些规则仍然看起来非常复杂且令人头疼。我个人为自己过度简化了这一点(如果我因此搬起石头砸自己的脚，那就这样吧:我想我会在医院呆 2 天，而不是头痛几十天):

• 对于聚合，每个数据成员都是从列表初始化器的元素初始化的
• 否则调用构造函数

---

Doesn't this beat the whole purpose of a deleted constructor?

嗯，我不知道，但解决方案是使 foo 不是聚合。最通用的不增加开销并且不改变对象使用语法的形式是让它从一个空结构继承:

struct dummy_t {};

struct foo : dummy_t {
  foo() = delete;
};

foo f{}; // ERROR call to deleted constructor

在某些情况下(我猜根本没有非静态成员)，另一种方法是删除析构函数(这将使对象在任何上下文中都不可实例化):

struct foo {
  ~foo() = delete;
};

foo f{}; // ERROR use of deleted function `foo::~foo()`

---

此答案使用的信息来自:

• C++14 value-initialization with deleted constructor

• What are Aggregates and PODs and how/why are they special?

• List initialization

• Aggregate initialization
• Direct initialization

非常感谢@M.M谁帮助更正和改进了这篇文章。