对c++11统一初始化语法的天真、乐观和哦..这么错误的看法

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

好处是:没有狭窄的隐式转换，最麻烦的解析没有问题，一致性(？)。我认为没有问题，因为我认为它们是相同的(除了给出的示例)。

但他们不是。

纯粹的疯狂故事

{} 调用默认构造函数。

... 除非:

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

那么看起来是不是用value来初始化对象？...即使对象已经删除了默认构造函数，{}也可以创建对象。这难道不是违背了已删除构造函数的全部目的吗？

...除非:

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

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

...除非:

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

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

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

好吧，也许这和第一个异常一样(值初始化对象)

...除非:

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

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

我确定我错过了一些。具有讽刺意味的是，它被称为uniform 初始化语法。我再说一遍: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)`

最佳答案

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

最大的区别在于 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)

TL;DR

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

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

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谁帮助纠正和改进了这篇文章。

关于c++ - 删除了默认构造函数。仍然可以创建对象...有时，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33988297/