Do the parentheses after the type name make a difference with new?

Question

If 'Test' is an ordinary class, is there any difference between: Test* test = new Test; and Test* test = new Test();

Answer 1

Short answer: No.

Longer answer:

The parenthesis after the type is used to pass parameters to the constructor of said type. Let's take a look at a couple of examples:

class myClass {

  int x;

public:

  myClass() : x(0) {} // Default constructor

  myClass(int _x) : x(_x) {} // Constructor with a single int initializer

  //...

};

int main(int argc, const char * argv[]) {

  myClass *myclass1 = new myClass; // Calls default constructor

  myClass *myclass2 = new myClass(); // Also calls default constructor

  myClass *myclass3 = new myClass(10); // Calls constructor with one int parameter

   

  //... Do stuff

   

  delete myclass1;

  delete myclass2;

  delete myclass3;

}

For bonus material, operator new can be overloaded and so we need a way to be able to pass parameters to our overloaded new, but at the same time, still allow constructor parameters to be passed to the type. To achieve this, parenthesis after the keyword new is used. Placement new uses this syntax, which is why the term 'placement syntax' is used to describe overloaded parameters being pass to operator new:

// Overloaded new

//

void *operator new(std::size_t size, int num) {

  std::cout << "Parameter passed is: " << num << '\n';

  return malloc(size);

}

int main(int argc, const char * argv[]) {

myClass *myclass4 = new(10) myClass(100); // Calls our overloaded new

//... Do stuff

}

Of course, you need to free() the memory that was allocated by our overloaded new operator... I'll leave that as an exercise for the reader :)

I hope this helps