在没有 warning/error 的情况下对引用进行隐式重新解释

Question

刚刚发现潜在崩溃的原因是编译器未经检查的野外转换，忽略了类型。这是预期行为还是编译器错误？

问题：当涉及类型定义时，可能会进行隐式重新解释转换，从而破坏类型系统。

#include <iostream>

template<class A, class B>
inline bool
isSameObject (A const& a, B const& b)
{
  return static_cast<const void*> (&a)
      == static_cast<const void*> (&b);
}


class Wau
  {
    int i = -1;
  };

class Miau
  {
  public:
    uint u = 1;
  };


int
main (int, char**)
{
  Wau wau;
  using ID = Miau &;
  ID wuff = ID(wau);      // <<---disaster

  std::cout << "Miau=" << wuff.u
            << " ref to same object: " <<std::boolalpha<< isSameObject (wau, wuff)
            << std::endl; 
  return 0;
}

我很震惊地发现 gcc-4.9、gcc-6.3 和 clang-3.8 可以毫无错误地接受这段代码并产生以下输出：

Miau=4294967295 ref to same object: true

请注意我使用类型构造函数语法 ID(wau)。我希望在 C 风格的转换中有这样的行为，即 (ID)wau。只有在使用新式花括号语法 ID{wau} 时，我们才会得到预期的错误...

~$ g++ -std=c++11 -o aua woot.cpp

woot.cpp: In function ‘int main(int, char**)’:
woot.cpp:31:21: error: no matching function for call to ‘Miau::Miau(<brace-enclosed initializer list>)’
     ID wuff = ID{wau};
                 ^
woot.cpp:10:7: note: candidate: constexpr Miau::Miau()
 class Miau
       ^~~~
woot.cpp:10:7: note:   candidate expects 0 arguments, 1 provided
woot.cpp:10:7: note: candidate: constexpr Miau::Miau(const Miau&)
woot.cpp:10:7: note:   no known conversion for argument 1 from ‘Wau’ to ‘const Miau&’
woot.cpp:10:7: note: candidate: constexpr Miau::Miau(Miau&&)
woot.cpp:10:7: note:   no known conversion for argument 1 from ‘Wau’ to ‘Miau&&’

不幸的是，由于 std::initializer_list 惨败，花括号语法在模板繁重的代码中经常是不可取的。所以对我来说这是一个严重的问题，因为类型系统的保护在这里有效地崩溃了。

有人可以解释这种行为背后的原因吗？
它是某种向后兼容性吗（再次叹息）？

Answer 1

it is possible to make an implicit reinterpret cast, undermining the type system.
ID wuff = ID(wau);

这不是“隐含”的重新解释转换。那是一个 explicit 类型转换。虽然，转换做重新解释的事实确实不容易看出。具体来说，强制转换的语法称为“函数式风格”。

如果您不确定显式类型转换（无论是使用函数语法还是 C 风格语法）执行的是什么类型的转换，那么您应该避免使用它。许多人会争辩说不应该使用显式类型转换。

如果您改用 static_cast，您将处于类型系统的保护范围内：

ID wuff = static_cast<ID>(wau);

error: non-const lvalue reference to type 'Miau' cannot bind to a value of unrelated type 'Wau'

简单地依赖隐式转换通常也是安全的：

ID wuff = wau;

error: non-const lvalue reference to type 'Miau' cannot bind to a value of unrelated type 'Wau'

Is this intended behaviour

是的。

or a compiler bug?

没有

Answer 2

要成为完整的语言律师，T(expression) 是 conversion expression 到 T^的结果1。此转换具有调用 class' 构造函数² 的效果。这就是为什么我们倾向于将只接受一个参数的非显式构造函数称为 转换构造函数 .

using ID = Miau &;
ID wuff = ID(wau);

这等同于将表达式转换为ID。由于 ID 不是 class 类型，因此会发生 C 样式转换。

Can someone explain the reasoning behind this behaviour?

我真的不知道为什么 is 曾经是 C++ 的一部分。这不是必需的。而且是有害的。

Is it some kind of backwards compatibility (again, sigh)?

不一定，从 C++11 到 C++20，我们已经看到了重大变化。这可能有一天会被删除，但我怀疑它会。

¹⁾

[expr.type.conv]

A simple-type-specifier or typename-specifier followed by a parenthesized optional expression-list or by a braced-init-list (the initializer) constructs a value of the specified type given the initializer. [...]

If the initializer is a parenthesized single expression, the type conversion expression is equivalent to the corresponding cast expression. [...]

²⁾（当T是class类型且存在这样的构造函数时）

[class.ctor]/2

A constructor is used to initialize objects of its class type. Because constructors do not have names, they are never found during name lookup; however an explicit type conversion using the functional notation ([expr.type.conv]) will cause a constructor to be called to initialize an object.

在没有 warning/error 的情况下对引用进行隐式重新解释

implicit reinterpret cast on reference without warning/error

c++

casting

language-lawyer

reinterpret-cast

c++11

`[expr.type.conv]`

`[class.ctor]/2`