In C++, what is the difference between X x = X(); type declaration and X x; declaration where X is the class

Question

In my code I encountered above kind of scenario. Under what circumstances we need to use above style of object creation? Cant we simply create object X x? What thing we have achieved in X x = X(); type declaration?

Answer 1

There is difference. X x = X() requires the copy constructor to be accessible.

For the following class:

struct Foo
{
    Foo() = default;
    Foo(Foo const&) = delete;
    void* ptr;
};

This will compile:

Foo foo;

and this won't:

Foo foo = Foo();

Furthermore, the first syntax results in default-initialization, so ptr has undetermined value, while the second would zero-initialize it to nullptr (if the copy constructor wasn't deleted or inaccessible).

The reasonable default is neither of those - uniform initialization syntax (available since C++11):

Foo foo{};

While less uniform than the name suggests, it leaves your object zero-initialized and is immune to most vexing parse.

Answer 2

You should almost always write either X x; or X x{};

When X is a class type, X x; declares x as a variable of type X and runs the default constructor to initialize it. It could be thought of as shorthand for X x();, except that, because of the most vexing parse, you can't actually write X x();.

X x{}; is a new feature in C++11. It's almost, but not quite, the same as X x;. The important difference is that, with X x{};, any data members the default constructor doesn't initialize will be automatically initialized to zero. With X x;, any such members will be left uninitialized. (With a well-written C++ class, there won't be any members left uninitialized, but X x{} is handy for POD structures, such as the ones you might get from system headers geared for plain C.)

X x = X(); is quite different. It's formally equivalent to

X __temp_0{};
X x(__temp_0);
__temp_0.~X();

except for some details of scope and naming that can't be expressed in the language. It creates an extra temporary variable of type X and default-initializes it. Then it uses X's copy constructor to initialize x from the temporary, and finally it destroys the temporary (running its destructor). Whether these two things have the same effects depends on what X's constructors and destructor do, and often also on how good your C++ compiler is at optimizing out "abstraction penalties". And it won't compile at all if X doesn't have an accessible, implicit copy constructor.