Why the copy constructor is called - c++

Question

I cannot undestand why a copy constructor is called instead of a compile error.
I have declare two classes A B , which are independent . A is not based/derived of B. The only connection between them is that in B I use an operator that converts B to A
I have defined an operator = that gets as an argument a const reference of B.
In main I have written the following instnace of B = instance of A. I expect that a compile error will be generated. But the operator = is called
class A {};
class B {
public:
// conversion from A (constructor):
B()
{
cout << "1." << endl;
}
B(const A& x)
{
cout << "4." << endl;
}
// conversion from A (assignment):
B& operator= (const B& x)
{
cout << "3." << endl;
return *this;
}
// conversion to A (type-cast operator)
operator A() {
cout << "2." << endl;
return A();
}
};
int main()
{
A foo;
B bar; // calls constructor
bar = foo; // calls assignment
//foo = bar; // calls type-cast operator
char c;
c = getchar();
return 0;
}
I expect compile error. But the following sequence is printed
1 4 3 .
I hardly undestand how the copy constructor is called and why the operator = does not generate problem
Thank you

Answer 1

You have an implicit constructor
B::B(const A&)
which performs the conversion that you don't want. You can change the signature to
explicit B(const A&);
to trigger a compilation error. Note that it's good practice to mark constructors with one argument explicit by default (there is a clang-tidy check for it, too), just to avoid such conversions by accident (IMHO, it would even be better if constructors that can be constructed with a single argument would be explicit by default with the ability to make the implicit).

Answer 2

It's not a copy constructor that you have, it's a conversion constructor. The conversion constructor is called because you can turn a A into a B.
Do this:
explicit B(const A& x)
And now you will forbid the implicit conversion from A to B.
When you do:
bar = foo;
The compiler looks for sensible operations and allows for one conversion at most. It can use the copy assignment from B, and it knows it can create a B out of an A (because the constructor is not explicit), so it does this silently.
As #lubgr said, clang-tidy has a rule to check these and this is part of the C++ core guidelines.

Answer 3

I expect the following compile error will be generated
no match for 'operator=' ... note: no known conversion for argument 1 from 'A' to 'const B&'
There is no reason to expect such error, because there is a known conversion from A to const B&. B has a converting constructor for A:
B(const A& x)
The only connection between them is that in B I use an operator that converts B to A
... and the second connection between them is that in B, you use a constructor that converts A to B.
You are right that this a conversion cunstroctor. But why this called when the assignement bar = foo takes place.
Because the given operand of the assignment has the type A, while the declared argument type is const B&.
In cases where the argument type does not match the declaration, the compiler checks whether there exists an implicit conversion sequence which could be used to convert the argument. As, A is implicitly convertible to B, such implicit conversion sequence exists and will be used.