c++ variable assignment, is this a normal way..?

Question

This may be a silly question, but still I'm a bit curious... Recently I was working on one of my former colleague projects, and I've noticed that he really loved to use something like this:

int foo(7);

instead of:

int foo = 7;

Is this a normal/good way to do in C++ language? Is there some kind of benefits to it? (Or is this just some silly programming style that he was into..?)

This really reminds me a bit of a good way how class member variables can be assigned in the class constructor... something like this:

class MyClass
{
public:
   MyClass(int foo) : mFoo(foo)
   { }

private:
   int   mFoo;
};

instead of this:

class MyClass
{
public:
   MyClass(int foo)
   {
      mFoo = foo; 
   }

private:
   int   mFoo;
};

Answer 1

For basic types there's no difference. Use whichever is consistent with the existing code and looks more natural to you.

Otherwise,

A a(x);

performs direct initialization, and

A a = x;

performs copy initialization.

The second part is a member initializer list, there's a bunch of Q&As about it on StackOverflow.

Answer 2

Both are valid. For builtin types they do the same thing; for class types there is a subtle difference.

MyClass m(7);  // uses MyClass(int)
MyClass n = 3; // uses MyClass(int) to create a temporary object,
               // then uses MyClass(const MyClass&) to copy the
               // temporary object into n

The obvious implication is that if MyClass has no copy constructor, or it has one but it isn't accessible, the attempted construction fails. If the construction would succeed, the compiler is allowed to skip the copy constructor and use MyClass(int) directly.