关于最令人烦恼的解析的令人困惑的细节

Question

我的问题是如何将以下行解析为函数声明：

vector<int> v(istream_iterator<int>(cin), istream_iterator<int>());

我了解最令人烦恼的解析的大部分细节以及为什么第二个临时迭代器可以解释为返回迭代器且不带参数的函数的类型，但我不明白的是为什么第一个临时迭代器可以解释为类型。它代表什么类型？我的想法是，这将是某种函数类型，但我看不出名称 cin 是如何使用的。它是否声明该参数是一个名为 cin 的 istream_iterator？如果是这样，这是否意味着您可以任意将函数的参数名称括起来？如果是这样，为什么？

Answer 1

istream_iterator(cin) 与 istream_iterator; 完全相同。 cin 但带有多余的括号。这种声明符语法是从 C 继承的，我认为甚至 C 的发明者（Ken Thompson？）也将其描述为错误。

Answer 2

我是否已经说过我（非常）喜欢 Clang ？

只需尝试以下（简化的代码）

#include <vector>

void foo(std::vector<int>);

int main() {
  std::vector<int> v(int(i), int());
  foo(v);
}

在新重新命名的 LLVM Try Out 中（嗯，它只是从 llvm-gcc 变为铛）。

你会得到：

/tmp/webcompile/_21483_0.cc:6:21: warning: parentheses were disambiguated
                                           as a function declarator
  std::vector<int> v(int(i), int());
                    ^~~~~~~~~~~~~~~
/tmp/webcompile/_21483_0.cc:7:3: error: no matching function for call to 'foo'
  foo(v);
  ^~~
/tmp/webcompile/_21483_0.cc:3:6: note: candidate function not viable:
     no known conversion from 'std::vector<int> (int, int (*)())'
     to 'std::vector<int>' for 1st argument
void foo(std::vector<int>);
     ^
3 diagnostics generated.

因此，@john 是对的，int(i) 被解释为 int i，即函数的命名参数。

Answer 3

是的，它是参数名称。而且，是的，您可以添加一组括号，因为有时您必须这样做。

如果参数是函数指针，则需要这样写void (*f)()。

编写标准的人没有花费宝贵的时间来准确指出允许或实际需要括号的情况，因此标准只是说您可以拥有它们。

Answer 4

标准 (2003) 中有一个名为歧义解决的部分专门讨论此类语法。我想如果您自己阅读该部分，我不需要进一步解释，因为它非常清楚，有很多例子！

所以你开始吧：

8.2 歧义解决 [dcl.ambig.res]

1 - 由于函数样式转换和 6.8 中提到的声明之间的相似性而产生的歧义也可能出现在声明的上下文中。 在这种情况下，可以在参数名称周围带有一组冗余括号的函数声明和带有函数样式强制转换作为初始值设定项的对象声明之间进行选择。正如 6.8 中提到的歧义一样，解决方案是考虑任何可能是声明的构造。 [注意：声明可以通过非函数风格的强制转换显式消除歧义，通过 = 来指示初始化或删除参数名称周围的多余括号。 ]

[Example:

struct S {
    S(int);
};

void foo(double a)
{
   S w(int(a));  // function declaration
   S x(int());   // function declaration
   S y((int)a);  // object declaration
   S z = int(a); // object declaration
}
—end example]

2 - 由于函数样式转换和类型 ID 之间的相似性而产生的歧义可能会出现在不同的上下文中。这种歧义表现为函数式转换表达式和类型声明之间的选择。 解决方案是，任何在其语法上下文中可能是类型 ID 的构造都应被视为类型 ID。

3- [Example:

#include <cstddef>

char *p;
void *operator new(size_t, int);

void foo() {
    const int x = 63;
    new (int(*p)) int; // new-placement expression
    new (int(*[x]));   // new type-id
}

//4 - For another example,

template <class T>
struct S {
    T *p;
};
S<int()> x;  // type-id
S<int(1)> y; // expression (ill-formed)

//5 - For another example,
void foo()
{
   sizeof(int(1)); // expression
   sizeof(int()); // type-id (ill-formed)
}

//6 - For another example,
void foo()
{
   (int(1)); //expression
   (int())1; //type-id (ill-formed)
}
—end example]

7 - 当类型名称嵌套在括号中时，函数声明的参数声明子句或作为 sizeof 或 typeid 运算符的操作数的 type-id 中会出现另一个歧义。 在这种情况下，需要在函数指针类型的参数声明和在声明符 ID 周围带有多余括号的参数声明之间进行选择。解决方案是将类型名称视为
简单类型说明符而不是声明符 ID。

[Example:

class C { };
void f(int(C)) { }    // void f(int (*fp)(C c)) { }
                      // not: void f(int C);
int g(C);
void foo() {
    f(1); //error: cannot convert 1 to function pointer
    f(g); //OK
}

//For another example,
class C { };
void h(int *(C[10]));  // void h(int *(*_fp)(C _parm[10]));
                      // not: void h(int *C[10]);

—end example]