Why does a function parameter call a constructor with an argument? - c++

Question

I have this code(stolen from cplusplus.com):
// explicit:
#include <iostream>
using namespace std;
class A {};
class B {
public:
explicit B (const A& x) {}
B& operator= (const A& x) {return *this;}
operator A() {return A();}
};
void fn (B x) {}
int main ()
{
A foo;
B bar (foo);
bar = foo;
foo = bar;
// fn (foo); // not allowed for explicit ctor.
fn (bar);
return 0;
}
So apparently the statement fn (foo); would call the constructor defined in class B, and I do not really get why. Why would that call a constructor with an argument, I mean aren't things simply copied to the function parameters when not using a reference? If fn (foo); calls the constructor B (const A& x) {}, shouldn't fn (bar); generate an error since there is no constructor defined for an argument of type B, such as B (const B& x) {}?

Answer 1

It's all because of fn()'s signature:
void fn (B x) {}
fn only accepts objects of type B, and passes them by value.
So what happens when calling fn() with an object of type A?
A foo;
fn (foo); // not allowed for explicit ctor.
The compiler tries to find the best matching function - a function called fn and receives type A. (Overload resolution)
Because there is no such function, it then tries to find the next best match by casting the object to a type that fn() accepts.
A conversion constructor would usually do the job : B (const A& x) {}
But because it's marked with an explicit specifier the compiler can't do it implicitly.
You would have to explicitly cast the object for the compiler to find a match:
fn ((B)foo); // Explicit conversion is allowed.

Answer 2

That is a result of an explicit creation of an object
fn(foo);
is not implicitly possible since fn() doesn't takes any A object as parameter
BUT your foo parameter can actually be used to create an instance of B which match perfectly the fn parameter, you can prevent that implicitly conversion of objects using the explicit keyword.
And that is what you are doing here:
explicit B (const A& x) {}

Answer 3

From the C++ Standard
15 The initialization that occurs in the = form of a brace-or-equal-initializer or condition (6.4), as well as in argument passing, function return, throwing an exception (15.1), handling an exception (15.3), and aggregate member initialization (8.6.1), is called copy-initialization. [ Note: Copy-nitialization may invoke a move (12.8).—end note ]
Thus for the explicit constructor
explicit B (const A& x) {}
this initialization that in fact is used for the initialization of the function parameter
A foo;
B bar = foo;
is wrong.
It is the direct initialization that can be used with the explicit constructor as it is shown in your program
A foo;
B bar( foo );

Answer 4

Well ... B(const B&) although not explicitly declared, is there. That's because it is one of the special functions for which the compiler has a default:
B()
B(const B&)
B(B&&)
B& operator=(const B&)
B& operator==(B&&)
~B()
So, B can copy itself.
It cannot convert implicitly form A being such a conversion is declared as explicit.
fn(B(foo)) would have worked.