Запутанная деталь о самом неприятном разборе

istream_iterator<int>(cin) точно такой же, как istream_iterator<int> cin, но с лишними скобками. Этот синтаксис декларатора был унаследован от C, и я думаю, что даже изобретатель C (Кен Томпсон?) назвал его ошибкой.

Я уже говорил, что мне нравится Clang (очень)?

Просто попробуйте следующее (упрощенный код)

#include <vector>

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

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

В недавно переименованном LLVM Try Out (ну, он просто перешел от llvm-gcc к clang).

И вы получаете:

/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, т.е. именованный параметр функции.

Да, это имя параметра. И да, вы можете добавить набор скобок, потому что иногда это необходимо.

Если параметр является указателем на функцию, void (*f)() вам нужно написать его так.

Люди, пишущие стандарт, не тратили свое драгоценное время на точное указание случаев, когда круглые скобки разрешены или действительно необходимы, поэтому стандарт просто говорит, что вы можете их использовать.

В Стандарте (2003 г.) есть раздел под названием Ambiguity resolution, посвященный таким синтаксисам. Я думаю, что мне не нужно объяснять это дальше, если вы сами прочитаете этот раздел, потому что он очень понятен и содержит множество примеров!

Итак, вот:

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. Неоднозначность, возникающая из-за сходства между приведением в стиле функции и идентификатором типа, может возникать в разных контекстах. Неоднозначность проявляется как выбор между выражением приведения в стиле функции и объявлением типа. Решение состоит в том, что любая конструкция, которая может быть идентификатором типа в ее синтаксическом контексте, должна считаться идентификатором типа.

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, когда имя типа заключено в круглые скобки. В этом случае выбор делается между объявлением параметра типа указателя на функцию и объявлением параметра с лишними круглыми скобками вокруг идентификатора декларатора. Решение состоит в том, чтобы рассматривать имя типа как спецификатор простого типа, а не как идентификатор декларатора.

[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]