is it necessary to overload placement new operator, when we overload new operator ?

Question

Hi, I have below piece of code

class Test 
{
public:
    Test(){}
    Test(int i) {}

  void* operator new (size_t size)
  {
      void *p = malloc(size);
      return p;
  }
  //void* operator new (size_t size, Test *p)
  //{
     // return p;
  //}
};

int main() { 
   Test *p = new Test;
   int i = 10;
   new(p) Test(i);
}

Above piece of code does not compile in visual studio, unless i uncomment out the overloaded placement new operator function. If i comment out normal overloaded new, in that case also it works fine. Is overloading of placement new mandatory when overloading normal new operator(If placement new need to be used for that class)

PS: Placement delete related code is not shown here.

Answer 1

Usually no, since it's not often used. But it might be necessary, since when you overload operator new in a class, it hides all overloads of the global ::operator new.

So, if you want to use placement new on objects of that class, do; otherwise don't. Same goes for nothrow new.

If you've just changed the allocation scheme, and you're surprised that someone somewhere is using placement new behind your back, that might be something to investigate before applying this band-aid.

If the class is used inside standard library containers, not directly with new, the custom allocation scheme should be defined by an Allocator class, not an overload. Sensitivity to the presence of placement new would be a symptom of that.

Answer 2

Placement new operator doesn't exist by default for a class so when you're making a call to new(p) Test(i); C++ compiler can't find a definition of the commented function in the above example. If you uncomment the placement operator new for your class, and comment out the "normal" one then the default "normal" new operator will be used and your code will compile.

Answer 3

implementations of std::_Construct use the global placement new. So concerns about STL compatability should not be concerns. But the concern about breaking existing code, that may have been written

new ((void*)p) thing;

rather than

::new ((void*)p) thing;

is certainly a valid point.