The Placement new Operator

Normally, the new operator has the responsibility of finding in the heap a block of memory

that is large enough to handle the amount of memory you request. The new operator has a

variation, called placement new, that allows you to specify the location to be used. A program-

mer might use this feature to set up his or her own memory-management procedures or to

deal with hardware that is accessed via a particular address.

To use the placement new feature, you first include the new header file, which provides a proto-

type for this version of new. Then you use new with an argument that provides the intended

address. Aside from this argument, the syntax is the same as for regular new. In particular, you

can use placement new either without or with brackets. 

Example

// newplace.cpp -- using placement new
#include <iostream>
#include <new> // for placement new
const int BUF = 512;
const int N = 5;
char buffer[BUF]; // chunk of memory

int main() {
using namespace std;
double *pd1, *pd2;
int i;
cout << "Calling new and placement new:\n";
pd1 = new double[N]; // use heap
pd2 = new (buffer) double[N]; // use buffer array
for (i = 0; i < N; i++)
pd2[i] = pd1[i] = 1000 + 20.0 * i;
cout << "Buffer addresses:\n" << " heap: " << pd1 << " static: "
<< (void *) buffer << endl;
cout << "Buffer contents:\n";
for (i = 0; i < N; i++) {
cout << pd1[i] << " at " << &pd1[i] << "; ";
cout << pd2[i] << " at " << &pd2[i] << endl;
}
cout << "\nCalling new and placement new a second time:\n";
double *pd3, *pd4;
pd3 = new double[N];
pd4 = new (buffer) double[N];
for (i = 0; i < N; i++)
pd4[i] = pd3[i] = 1000 + 20.0 * i;
cout << "Buffer contents:\n";
for (i = 0; i < N; i++) {
cout << pd3[i] << " at " << &pd3[i] << "; ";
cout << pd4[i] << " at " << &pd4[i] << endl;
}
cout << "\nCalling new and placement new a third time:\n";
delete[] pd1;
pd1 = new double[N];
pd2 = new (buffer + N * sizeof(double)) double[N];
for (i = 0; i < N; i++)
pd2[i] = pd1[i] = 1000 + 20.0 * i;
cout << "Buffer contents:\n";
for (i = 0; i < N; i++) {
cout << pd1[i] << " at " << &pd1[i] << "; ";
cout << pd2[i] << " at " << &pd2[i] << endl;
}
delete[] pd1;
delete[] pd3;
return 0;
}

Result is:

Calling new and placement new:
Buffer addresses:
heap: 0x9a35008 static: 0x804a0e0
Buffer contents:
1000 at 0x9a35008; 1000 at 0x804a0e0
1020 at 0x9a35010; 1020 at 0x804a0e8
1040 at 0x9a35018; 1040 at 0x804a0f0
1060 at 0x9a35020; 1060 at 0x804a0f8
1080 at 0x9a35028; 1080 at 0x804a100

Calling new and placement new a second time:
Buffer contents:
1000 at 0x9a35038; 1000 at 0x804a0e0
1020 at 0x9a35040; 1020 at 0x804a0e8
1040 at 0x9a35048; 1040 at 0x804a0f0
1060 at 0x9a35050; 1060 at 0x804a0f8
1080 at 0x9a35058; 1080 at 0x804a100

Calling new and placement new a third time:
Buffer contents:
1000 at 0x9a35008; 1000 at 0x804a108
1020 at 0x9a35010; 1020 at 0x804a110
1040 at 0x9a35018; 1040 at 0x804a118
1060 at 0x9a35020; 1060 at 0x804a120
1080 at 0x9a35028; 1080 at 0x804a128

The important fact here is that placement new simply uses the address that is passed to it; it doesn’t

keep track of whether that location has already been used, and it doesn’t search the block for

unused memory. 

The memory specified by buffer
is static memory, and delete can be used only with a pointer to heap memory allocated by

regular new. That is, the buffer array is outside the jurisdiction of delete, and the statement

delete [] pd2;  // won’t work

will produce a runtime error. On the other hand, if you use regular new to create a buffer in the

first place, you use regular delete to free that entire block.