Why is copy constructor called instead of conversion constructor?

Question

So basically this code:

class A {
};
class B { 
   B (const B& b) {}
public: 
   B (){}
   B (const A& a) {} 
};

int main()
{
   A a;
   B b1(a);  //OK
   B b2 = a; //Error
}

only generates an error for B b2 = a. And that error is

error: ‘B::B(const B&)’ is private

Why is it attempting to call the copy constructor in addition to the direct conversion constructor?

It's clear from the error message that a temporary B is created which is then used for copy-construction, but why? Where is this in the standard?

Throve

Is your question related, by any chance, to this one? :) – Airworthy

Because I've reviewed that question a few minutes ago :) – Airworthy

So to be clear, are you asking why the compiler is doing it (i.e. you want the standard reference for the definition of copy initialization), or are you asking why the standard is doing it (i.e. you want the motivation for that definition)? – Rhearheba

@SteveJessop I'm asking for the reference first, but the motivation would also be nice to know (not gonna post a new question as it will likely get deleted). – Throve

@SteveJessop fair. I think Jesse's comment to Als' answer is a probable explanation. – Throve

@Luchian: I agree it's a possibility, although I think its deduction could be counter-argued. Every built-in type can be trivially copied, so I don't think it's quite true that having only the conversion wouldn't mimic the semantics -- the semantics of direct initialization and copy initialization are identical for built-in types. There's something it doesn't mimic though. I guess the problem with "motivation" questions is that people show their working for these deductions and counter-arguments in answers, when they don't have a direct source! – Rhearheba

@SteveJessop posted new question stackoverflow.com/questions/11223285/… – Throve

Answer 1

B b2 = a;

This is known as Copy Initialization.

It does the following:

1. Create an object of type B from a by using B (const A& a).
2. Copy the created temporary object to b2 by using B (const B& b).
3. Destroy the temporary object by using ~B().

The error you get is not at step 1 but rather at step 2.

Where is this in the standard?

C++03 8.5 Initializers
Para 14:

....
— If the destination type is a (possibly cv-qualified) class type:
...
...
— 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). If the conversion cannot be done or is ambiguous, the initialization is ill-formed. The function selected is called with the initializer expression as its argument; if the function is a constructor, the call initializes a temporary of the destination type. The result of the call (which is the temporary for the constructor case) is then used to direct-initialize, according to the rules above, the object that is the destination of the copy-initialization. In certain cases, an implementation is permitted to eliminate the copying inherent in this direct-initialization by constructing the intermediate result directly into the object being initialized; see 12.2, 12.8.

Machination

But why not directly use the conversion constructor? – Throve

@LuchianGrigore: It does.The error is after the conversion has been done, during copy construction.The call to copy constructor could be elided as well, but that depends on the compiler.Also, still the copy constructor needs to be accessible. – Machination

Yes, I got that (and I know they have to be visible regardless of whether they are called or not). But why doesn't it just do it in one step? Why the need for a temporary B? – Throve

Ok, poor phrasing on my part in the question. Edited :) – Throve

Thanks! I'd ask what the motivation behind this is, but that'd just get closed. – Throve

@LuchianGrigore: I think the reason is to be closer to the semantics of built-in types. For example, int i = 1.0;: 2 things happen here. 1.0 is converted to an int and then the value is assigned to i, having only a conversion operator would not mimic the semantics (I believe). – Tetzel

@JesseGood see stackoverflow.com/questions/11223285/… – Throve