在表达式陈述开始时，`是``auto（expr）'被视为铸件吗？

Question

我有一个简单的代码段（ httpps://godbolt.org/z/cpt​​3phydj ）：

int main() {
  int x = 1;
  auto(1); // ok in GCC, error in Clang
  auto{1}; // ok in GCC, error in Clang
  static_cast<void>(auto(x)); // ok
  auto{x}; // ok in GCC, error in Clang
  auto(x); // both error in GCC an Clang
}

GCC和Clang都会发出错误：

// by GCC Trunk [-std=c++23]
<source>: In function 'int main()':
<source>:7:3: error: declaration of 'auto x' has no initializer
    7 |   auto(x); // why
      |   ^~~~
Compiler returned: 1

// by Clang Trunk [-std=c++2b]
<source>:3:8: error: expected unqualified-id
  auto(1); // why
       ^
<source>:3:8: error: expected ')'
<source>:3:7: note: to match this '('
  auto(1); // why
      ^
<source>:4:7: error: expected unqualified-id
  auto{1}; // why
      ^
<source>:6:7: error: expected unqualified-id
  auto{x}; // why
      ^
<source>:7:8: error: redefinition of 'x'
  auto(x); // why
       ^
<source>:2:7: note: previous definition is here
  int x = 1;
      ^
<source>:7:8: error: declaration of variable 'x' with deduced type 'auto' requires an initializer
  auto(x); // why
       ^
6 errors generated.
Compiler returned: 1

• 如果C ++ 23是实验性的，并且由于引入了另一个auto（expr），他们是否能够修复歧义或更改歧义。还是离开它？

• 这些表达式是否应该被解析为显式类型的衰减转换auto（expr）或auto {expr}在表达式语句中或以声明为单位？

• 如果没有歧义，则首先要优先考虑：

  • auto（标识符） AS 自动标识符？或
  • auto（标识符）作为铸造表达式？

Answer 1

来自显式铸造转换：

  auto（表达式）（8）（自C ++ 23）

auto {expression}（9）（由于C ++ 23）
 

8,9）auto用auto> auto x（expression）;声明的发明变量x的定义类型替换了指定词。 （从未解释为函数声明）或auto x {expression};。结果始终是对象类型的prvalue。

因此，似乎（按照上述语句允许您使用）。

在这里是您代码的工作演示。注意在链接的演示中，仅使用auto（x）会产生错误，所有其他情况都可以正常工作。

---

另请注意，从 pr105516 ：：：：::

auto（x）;被解释为auto x;。使用+auto（x）;如果您希望它是表达式。

---

如果没有歧义，则首先要优先考虑：

这是一个示例之一，显示了C ++是上下文敏感语言。如果不知道其更广泛的上下文，就不能总是理解构造。考虑以下示例：

int main()
{
    int x = 0   ;
    int k       ;
//------vvvvvvv----->here auto(x) is behaves as an expression as it is used as an expression 
    k = auto(x) ;

    auto(p)     ;  //this a declaration and not an explicit case unlike the above
}

Answer 2

据我所知A>引入此功能没有任何进一步的相关更改，除了允许auto作为功能风格的显式铸件中的类型说明器。

因此，直观地自动在这里的行为应与任何其他类型的规范符相同。

例如，用auto int 替换，预计所有这些情况都可以正常工作并且是功能上的显式

int(x); // auto(x);

演员声明一个名为x的变量 int （或占位符类型），并带有声明器周围的括号，而没有初始化器。

与往常一样，语法是通过偏爱解释为声明的（参见 .ambig]/1 ）。至少，我认为对于auto，它应该没有不同。具有auto占位符类型的声明需要一个初始化器，但在此解释中不存在，而是根据 [stmt.ambig]/3 即使歧义也应很早，纯粹是句法的，即使它以不良形式的声明结束。我不完全确定，但我想这应该意味着auto（x）;仍然应该被视为声明。

我不知道为什么Clang给其他许多行都会出现错误。我想该功能要么仅部分实现，要么是实现错误（这是未完成的标准修订中的一个非常新的功能）。

Answer 3

我认为auto（x）（其中x实际上是标识符）仍然可以在不同的上下文中具有不同的含义，因此受 [dcl.ambig.res] 在C ++ 23中。

不幸的是，歧义不太可能被修复。在以下程序中（自C ++ 11以来良好的程序），auto（x）= bar {};被解释为声明。如果auto（x）被“修复”，则auto（x）= bar {};将成为一个表达式语句，它将改变现有行为。

#include <cstdio>
struct Bar {
    Bar()
    {
        std::puts("initialization");
    }
};

struct Foo {
    void operator=(Bar)
    {
        std::puts("assignment");
    }
};

int main()
{
    Foo x{};
    {
        auto(x) = Bar{}; // only prints "initialization"
    }
}