Copy-initialization with implicit conversion in c++

Question

class Foo {
  public:
    Foo(float b) {}
};

class Bar {
  public:
    Bar(Foo foo) {}
};

int main(int argc, char *argv[]) {
    Bar b1(3.0f);  // accept, one implicit convertion happens there.
    Bar b2 = 3.0f;  // error: no viable conversion from 'float' to 'Bar'
    return 0;
}

Why does the second expression fail to compile? I expected that it would call the same converting constructor as same as the first expression.

Answer 1

From [dcl.init]:

Otherwise (i.e., for the remaining copy-initialization cases), user-defined conversion sequences that can convert from the source type to the destination type or (when a conversion function is used) to a derived class thereof are enumerated as described in 13.3.1.4, and the best one is chosen through overload resolution (13.3).

We can invoke a user-defined conversion that is from the source type directly to the target type. That is, if we had Bar(float ), we would consider that constructor. However, in this case, our candidate is simply Bar(Foo ), which does not take a float.

You are allowed zero or one user-defined conversion. In the direct-initialization case, we simply call Bar(Foo ) which invokes one user-defined conversion (float --> Foo). In the copy-initialization case, we are looking for a conversion sequence from float (the source type) all the way to Bar (the destination type), which would involve two user-defined conversions (float --> Foo, Foo --> Bar), hence the error.

Answer 2

The second type of initialization is called copy-initialization and uses copy constructor. Therefore, this type of initialization expects the right side is convertible to Bar.