Question

What’s the difference between the following two declarations, assuming I have not specified a copy constructor and operator= in class Beatle?

Beatle john(paul);

and

Beatle john = paul;

Edit:

In objects assignment, the operator = implicitly calls the copy constructor unless told otherwise?

Answer 1

They’re different grammatical constructions. The first one is direct initialization, the second is copy initialization. They behave virtually identically, only that the second requires a non-explicit constructor.*

Neither has anything to do with the assignment operator, as both lines are initializations.

To wit: const int i = 4; is fine, but const int i; i = 4; is not.

*) More accurately: The second version does not work if the relevant constructor is declared explicit. More generally, thus, direct-initialization affords you one “free” conversion:

struct Foo { Foo(std::string) {} };

Foo x("abc");  // OK: char(&)[4] -> const char * -> std::string -> Foo
Foo y = "abd"; // Error: no one-step implicit conversion of UDTs

---

To address your edit: To understand the assignment operator, just break it up into parts. Suppose Foo has the obvious operator=(const Foo & rhs). We can say x = y;, which just calls the operator directly with rhs being y. Now consider this:

x = "abc";              // error, no one-step implicit conversion
x = std::string("abc"); // fine, uses Foo(std::string), then copy
x = Foo("abc");         // fine, implicit char(&)[4] -> const char* -> std::string, then as above