What happens behind the scenes when manually calling a constructor in C++?

This can best be explained with the help of a small example:

Live on Coliru

struct A {
  A(int a) { cout << "A::ctor\n"; }                      //ctor
  A(const A& a) { cout << "A::copy\n"; }                 //copy ctor
  A& operator=(const A& a) { cout << "A::operator=\n"; } //copy assign
};

int main()
{
    A a(2);     //calls constructor
    a = A(10); //calls constructor first, then copy assignment
}

Output:

A::ctor
A::ctor
A::operator

The above is pretty self explanatory. For the first, only the constructor gets called. For the second, first the constructor is called and then copy assignment.

SomeClass does not have operator= implemented.

That doesn't matter because the compiler can generate one for you. If you explicitly delete it, then the above code will not compile. However, if you have a move constructor defined then that will be used:

(I highly recommend you read The rule of three/five/zero and understand it. It is among the top 5 things in C++ that you should know.)

    A& operator=(const A& a) = delete; //copy assign deleted
    A& operator=(A&& other) { cout << "move assigned\n"; } //move assign available

Now you maybe wondering what will happen if both copy and move assign are available. Lets see:

    A a(2);           //ctor
    a = A(10);        //ctor + move assign
    A b(3);           //ctor
    b = a;            // copy assign only
    a = std::move(b); // move assign

For a = A(10) move assign is invoked because A(10) is an rvalue of the same type as what is on the left hand side of the =.

For the last case a = std::move(b);, we explicitly cast b to an rvalue (yes that's what std::move() does). Since it's an rvalue now, move assignment is invoked.

Does the space allocated to x simply get overwritten as if it was newly allocated memory or what exactly happens?

• First the temporary is created: A(10). Space will of course be allocated for it.
• It's result is then assigned to a, so previous values in a get overwritten
• destructor for the temporary will be called

And when is it a good idea?

It is a good idea when you need it, it depends on your usecase. Generally I would recommend that don't copy assign unnecessarily.

Second line is call of constructor followed by call to assignment operator. Assigment default to shallow copy of non-static members into existing storage.

If you defined something that prevented compiler to create default operator=, i.e. you defined move constructor or move assignment, no assignment is possible unless you declared your own (why it is so surprising?) If default shallow copy is fine, you can write following declaration:

SomeClass& operator(const SomeClass&) = default;

= default provides mechanism to declare "default" behavior of special functions.

Now there is move assignment and in such case one would be preferred if it declared in given context. But it won't be declared by compiler if user provided destructor or copy\move constructor\assignment operator.

SomeClass& operator(SomeClass&&) = default;

Difference between two assignments exists only for class-types where "move" semantics may include transfer of ownership. For trivial types and primitive types it's a simple copy.

Compiler allowed to elide some actions including creation of storage for temporary object, so resulting code may actually write new values directly into x storage, provided that such elision won't change program behavior.