How the C++ most vexing parse is possible in this example?

Question

I read that this code A a( A() ); was interpreted by the compiler as a function declaration while here I clearly see that A() is a function that returns an object. How can it be something else that the construction of a A object ?

I've just read entirely the Function declaration page of cppreference : https://en.cppreference.com/w/cpp/language/function and I don't see anywhere that the parameters list can look like that A().

I don't understand how The most vexing parse can be valid C++.

`A()` is an unnamed parameter of type `A()`, which is a type of a function returning `A` with no arguments. E.g. `std::function`. It's decayed (or something) to a function pointer when used in an argument. So it's actually `A some_function(A (*parameter_which_is_a_function)())`. — yeputons, Nov 06 '22 at 00:14
This is one reason why C++ added braces for initialization, `A{}`, which cannot be a function. — BoP, Nov 06 '22 at 08:25

Nathan Pierson · Answer 1 · 2022-11-06T00:11:31.977

6

A() isn't a function declaration by itself, but it can be the type of a function.

For instance, suppose I declare the following function: A makeAnA();. The type of makeAnA is A(): A function that takes no arguments and returns an A.

Quoting cppreference on functions:

Each function has a type, which consists of the function's return type, the types of all parameters (after array-to-pointer and function-to-pointer transformations, see parameter list) , whether the function is noexcept or not (since C++17), and, for non-static member functions, cv-qualification and ref-qualification (since C++11). Function types also have language linkage.

So a function that has zero parameters, returns an A, and isn't noexcept has the type A().

Therefore, it's possible to interpret A a( A() ); as a function declaration. It declares that a accepts a single, unnamed argument of type A(), and returns an A as its result. Because it's possible to interpret this as a function declaration, it is required by the standard that it is so interpreted.

edited Nov 06 '22 at 00:11

answered Nov 06 '22 at 00:03

Nathan Pierson

5,461
1
12
30

"It declares that `a` accepts a single, unnamed argument of type `A()`" I don't get it. `A()` is an object. It's not a type. As far as I know... – Autechre Nov 06 '22 at 00:07
1

@Autechre The token sequence `A` `(` `)` can be an expression (specifically a functional-style explicit cast which creates a value-initialized temporary `A` object). But the token sequence may also denote a _type_ instead of being an expression. It is the type of a function without any parameters and returning `A`, e.g. `std::function` uses `A()` as a type name as the template argument. Because both meanings could be used in `A a( A() );` C++ grammar would be ambiguous if there wasn't the tie breaker to always prefer the interpretation as type when possible. – user17732522 Nov 06 '22 at 00:16
If the function `A()` is interpreted as a parameter of type `A` why this declaration is legal `A a( A() );` since it's equivalent to `A a( A );` ? I think C++ could forbid misleading function declarations like `A a( A() );` and only allows declarations like this `A a( A );`. If it was the case there wouldn't be the C++ most vexing parse problem. – Autechre Nov 06 '22 at 00:38
It's not interpreted as a parameter of type `A`. It's interpreted as a parameter of type `A()`. `A a (A() );` is _not_ equivalent to `A a( A );`. The latter declares a function which accepts an `A` object, which is not the same thing as an `A()` function. – Nathan Pierson Nov 06 '22 at 00:40
In that case, I didn't know the function object type existed in C++. My bad. I never saw this object type anywhere. I came across this link which seems to be this function object we're talking about https://en.cppreference.com/w/cpp/named_req/FunctionObject but even there I don't see the syntax used in the most vexing parse. Maybe I'm just very unexperienced but it's a bit like this function object syntax `A()` only exists to create confusion. – Autechre Nov 06 '22 at 01:06
@Autechre No, _function objects_ are objects, but _functions_ are not objects. And we are not saying that `A()` is a _function_. We are saying that it is a _function type_, i.e. a syntax to refer to the type of a function, like `int` would be a syntax to refer to the type of an object with that type. For example this is valid: `using T = A(); T foo;` It defines a type alias `T` for the type `A()` and then declares an entity `foo` with that type. Because `A()` is the type of a function with no parameters returning `A`, this is also the type of `foo`, i.e. it is equivalent to `A foo();`. – user17732522 Nov 06 '22 at 01:20
@Autechre The type syntax is older by the way. It is inherited from C. C++ added the functional cast meaning which doesn't exist in C. Also, it is useful to be able to refer to a function type in code without having to talk about function pointers all the time, especially when you have templates that are supposed to operate on functions. E.g. `std::function`, which is an type that can hold any kind of callable that can be called like a function of type `A()` could. The alternative would be to talk about function pointer types, i.e. `A(*)()`, instead which isn't pretty either. – user17732522 Nov 06 '22 at 01:22

How the C++ most vexing parse is possible in this example?

1 Answers1