Conversion operator in direct-initialization

Question

The C++14 standard (N4296) says in 8.5/17.6.1

If the initialization is direct-initialization [...], constructors are considered. The applicable constructors are enumerated, and the best one is chosen through overload resolution. [...] If no constructor applies, or the overload resolution is ambiguous, the initialization is ill-formed.

Therefore in direct-initialization, only constructors are considered - conversion functions are ignored. In the following code there is no applicable constructor of A, only a conversion function from B. However, the code compiles, why?

struct A{};
struct B{
    operator A(){ return A{}; }
};

int main() {
    B b;
    A a(b);  // direct-initialization
}

Part of *chosen through overload resolution* is applying conversions. I'll try and find the applicable section. — NathanOliver, Jun 20 '19 at 16:38
Please explain why you believe it should not find a copy constructor. — curiousguy, Jun 21 '19 at 07:50

NathanOliver · Accepted Answer · 2019-06-20T17:23:10.850

You are correct that only the constructors of A are considered when doing A a(b);. [over.match.ctor]/1 states

When objects of class type are direct-initialized, copy-initialized from an expression of the same or a derived class type ([dcl.init]), or default-initialized, overload resolution selects the constructor. For direct-initialization or default-initialization that is not in the context of copy-initialization, the candidate functions are all the constructors of the class of the object being initialized. For copy-initialization (including default initialization in the context of copy-initialization), the candidate functions are all the converting constructors ([class.conv.ctor]) of that class. The argument list is the expression-list or assignment-expression of the initializer.

^{emphasis mine}

This means that A(), A(const A&) and A(A&&) are the candidate list. Then we have [over.match.viable]/4

[...]Third, for F to be a viable function, there shall exist for each argument an implicit conversion sequence that converts that argument to the corresponding parameter of F.[..]

which allows an implicit conversion of b to an A so that A(A&&) can be called.

Thanks for the correction, I have removed my answer as this is the right paragraph — KostasRim, Jun 20 '19 at 16:53
Wouldn't the move-constructor also be considered (and preferred) because `B` can be converted to a prvalue `A`? — David G, Jun 20 '19 at 17:20
@0x499602D2 Yep. Forgot about the move constructor. Answer updated. — NathanOliver, Jun 20 '19 at 17:23

Conversion operator in direct-initialization

1 Answers1

Linked