int a = 0 and int a(0) differences [duplicate]

They're both the same, so there really is no one "best way".

I personally use

int a = 0; 

because I find it more clear and it's more widely used in practice.

This applies to your code, where the type is int. For class-types, the first is copy-initialization, whereas the other is direct-initialization, so in that case it would make a difference.

There's no "best" way. For scalar types (like int in your example) both forms have exactly the same effect.

The int a(0) syntax for non-class types was introduced to support uniform direct-initialization syntax for class and non-class types, which is very useful in type-independent (template) code.

In non-template code the int a(0) is not needed. It is completely up to you whether you want to use the int a(0) syntax, or prefer to stick to more traditional int a = 0 syntax. Both do the same thing. The latter is more readable, in my opinion.

From a practical point of view: I would only use int a = 0;.

The int a(0) may be allowed but never used in practice in itself.

I think it should not bother you on your level, but let us go further.

Let's say that a is a class, not an int.

class Demo{ public: Demo(){}; Demo(int){}; }; Demo a; Demo b(a); Demo c = a; // clearly expressing copy-init 

In this example both b(a) and c=a do the same, and I would discourage you using the fist solution. My reason is, that is looks similar to c(2) which is a construction from arguments.

There are only two valid uses of this bracket-style initialization:

• initialization lists (Demo(int i):data(i){} if Demo has an int data member data),
• new's: Demo *p=new Demo(a); // copy constructing a pointer

It’s that simple. (Well, almost — there are a few things you can’t name your variables, which we’ll talk about in the next section)

You can also assign values to your variables upon declaration. When we assign values to a variable using the assignment operator (equals sign), it’s called an explicit assignment:

int a= 5; // explicit assignment 

You can also assign values to variables using an implicit assignment:

int a(5); // implicit assignment 

Even though implicit assignments look a lot like function calls, the compiler keeps track of which names are variables and which are functions so that they can be resolved properly.

In textbooks and literature, one is direct initialization and the other is copy initialization. But, in terms of machine code, there is no difference.

The difference is that () initialization is when you explicitly want it to take one parameter only, e.g:

You can:
int a = 44 + 2;
but you can't:
int a(44) + 2;