c++ - 聚合初始化的 C++17 扩展是否使大括号初始化变得危险？

Question

似乎普遍认为brace initialization should be preferred超过其他形式的初始化，但是自从引入 C++17 extension to aggregate initialization似乎存在意外转换的风险。考虑以下代码:

struct B { int i; };
struct D : B { char j; };
struct E : B { float k; };

void f( const D& d )
{
  E e1 = d;   // error C2440: 'initializing': cannot convert from 'D' to 'E'
  E e2( d );  // error C2440: 'initializing': cannot convert from 'D' to 'E'
  E e3{ d };  // OK in C++17 ???
}

struct F
{
  F( D d ) : e{ d } {}  // OK in C++17 ???
  E e;
};

在上面的代码中，struct D和struct E代表了两个完全不相关的类型。所以令我惊讶的是，从 C++17 开始，如果您使用大括号(聚合)初始化，您可以在没有任何警告的情况下从一种类型“转换”为另一种类型。

您有什么建议来避免这些类型的意外转化？还是我错过了什么？

PS:上面的代码在 Clang、GCC 和最新的 VC++ 中测试过——它们都是一样的。

更新:回应 Nicol 的回答。考虑一个更实际的例子:

struct point { int x; int y; };
struct circle : point { int r; };
struct rectangle : point { int sx; int sy; };

void move( point& p );

void f( circle c )
{
  move( c ); // OK, makes sense
  rectangle r1( c );  // Error, as it should be
  rectangle r2{ c };  // OK ???
}

我可以理解您可以将 circle 视为 point，因为 circle 以 point 为基础类，但是您可以默默地将圆形转换为矩形的想法对我来说是个问题。

更新 2:因为我对类名的错误选择似乎让某些人感到困惑。

struct shape { int x; int y; };
struct circle : shape { int r; };
struct rectangle : shape { int sx; int sy; };

void move( shape& p );

void f( circle c )
{
  move( c ); // OK, makes sense
  rectangle r1( c );  // Error, as it should be
  rectangle r2{ c };  // OK ???
}

Answer 1

struct D and struct E represent two completely unrelated types.

但它们不是“完全不相关”的类型。它们都具有相同的基类类型。这意味着每个 D 都可以隐式转换为 B。因此每个D 都是一个 B。所以 E e{d}; 和 E e{b}; 在调用的操作上没有区别。

您不能关闭到基类的隐式转换。

如果这真的让您感到困扰，唯一的解决方案是通过提供将值转发给成员的适当构造函数来防止聚合初始化。

至于这是否会使聚合初始化更加危险，我不这么认为。您可以使用这些结构重现上述情况:

struct B { int i; };
struct D { B b; char j; operator B() {return b;} };
struct E { B b; float k; };

所以这种性质的东西总是有可能的。我不认为使用隐式基类转换会使它变得“更糟”。

一个更深层次的问题是，为什么用户尝试用 D 来初始化 E。

the idea that you can silently convert from a circle to a rectangle, that to me is a problem.

如果你这样做，你会遇到同样的问题:

struct rectangle
{
  rectangle(point p);

  int sx; int sy;
  point p;
};

你不仅可以执行rectangle r{c};，还可以执行rectangle r(c)。

您的问题是您错误地使用了继承。你说的是 circle、rectangle 和 point 之间的关系，你不是这个意思。因此，编译器可以让你做你不想做的事情。

如果您使用包含而不是继承，这将不是问题:

struct point { int x; int y; };
struct circle { point center; int r; };
struct rectangle { point top_left; int sx; int sy; };

void move( point& p );

void f( circle c )
{
  move( c ); // Error, as it should, since a circle is not a point.
  rectangle r1( c );  // Error, as it should be
  rectangle r2{ c };  // Error, as it should be.
}

circle 要么是 always 一个 point，要么它是 never 一个 point。您有时会尝试使其成为 point 而不是其他人。这在逻辑上是不连贯的。如果你创建逻辑不连贯的类型，那么你可以编写逻辑不连贯的代码。

---

the idea that you can silently convert from a circle to a rectangle, that to me is a problem.

这带来了一个重要的观点。严格来说，转换如下所示:

circle cr = ...
rectangle rect = cr;

这是不正确的。当您执行rectangle rect = {cr}; 时，您没有 进行转换。您正在显式调用列表初始化，这对于聚合通常会引发聚合初始化。

现在，列表初始化当然可以执行转换。但是仅考虑 D d = {e};，人们不应该期望这意味着您正在执行从 e 到 D 的转换.您正在使用 e 对 D 类型的对象进行列表初始化。如果 E 可转换为 D 则可以执行转换，但如果非转换列表初始化形式也可以工作，则此初始化仍然有效。

所以说这个特性让circle可以转换成rectangle是不正确的。