Prayagasoft - web designer India, Ecommerce developer india, Ecommerce design

Placement New/Delete

In C++, operators new/delete mostly replace the use of malloc() and free() in C. For example:

class A { public: A(); ~A(); }; A* p = new A; ... delete p;

allocates storage for an A object and arranges for its constructor to be called, later followed by invocation of the destructor and freeing of the storage. You can use the standard new/delete functions in the library, or define your own globally and/or on a per-class basis.

There's a variation on new/delete worth mentioning. It's possible to supply additional parameters to a new call, for example:

A* p = new (a, b) A;

where a and b are arbitrary expressions; this is known as "placement new". For example, suppose that you have an object instance of a specialized class named Alloc that you want to pass to the new operator, so that new can control allocation according to the state of this object (that is, a specialized storage allocator):

class Alloc {/* stuff */}; Alloc allocator; ... class A {/* stuff */}; ... A* p = new (allocator) A;

If you do this, then you need to define your own new function, like this:

void* operator new(size_t s, Alloc& a) { // stuff }

The first parameter is always of type "size_t" (typically unsigned int), and any additional parameters are then listed. In this example, the "a" instance of Alloc might be examined to determine what strategy to use to allocate space. A similar approach can be used for operator new[] used for arrays.

This feature has been around for a while. A relatively new feature that goes along with it is placement delete. If during object initialization as part of a placement new call, for example during constructor invocation on a class object instance, an exception is thrown, then a matching placement delete call is made, with the same arguments and values as to placement new. In the example above, a matching function would be:

void operator delete(void* p, Alloc& a) { // stuff }

With new, the first parameter is always "size_t", and with delete, always "void*". So "matching" in this instance means all other parameters match. "a" would have the value as was passed to new earlier.

Here's a simple example:

int flag = 0; typedef unsigned int size_t; void operator delete(void* p, int i) { flag = 1; } void* operator new(size_t s, int i) { return new char[s]; } class A { public: A() {throw -37;} }; int main() { try { A* p = new (1234) A; } catch (int i) { } if (flag == 0) return 1; else return 0; }

Placement delete may not be in your local C++ compiler as yet. In compilers without this feature, memory will leak. Note also that you can't call overloaded operator delete directly via the operator syntax; you'd have to code it as a regular function call.