Understanding C++ Placement Syntax

Recently, the group reading activity has given me a deeper understanding of placement new and placement delete.

About the new Expression

C++ provides the new keyword and the delete keyword, which are used for allocating and releasing memory space, respectively. The syntax of the new expression is as follows:

new new-type-id ( optional-initializer-expression-list )

The book states that the new expression does two things:

• Allocates a block of memory on the heap, the size of which is equal to sizeof(new-type-id)
• Constructs an object in the allocated space, i.e., calls the object’s constructor

Additionally, I learned that if a user wants to construct an object in a custom memory space, they can call another new expression, with the following syntax:

new ( expression-list ) new-type-id ( optional-initializer-expression-list )

Specifically, it is used like this:

void *buffer = malloc(sizeof(ClassA));
ClassA *ptr = new(buffer)ClassA();

The second type of new expression is a special case of the first, only needing to complete step 2, while leaving step 1 to the user.

About the delete Expression

The syntax of the delete expression provided by C++ is:

delete type_pointer;

The book states that delete performs two actions:

• Calls the object’s destructor,
• Releases the memory space occupied by the object back to the system

It is particularly important to note that setting type_pointer to NULL allows the delete expression to function correctly, but calling delete on the same pointer multiple times will lead to undefined behavior.

Standard operator new and operator delete

The standard new expression in C++ internally calls the standard operator new(), which is defined as follows:

void * operator new (std::size_t) throw(std::bad_alloc);

operator new() is an operator or function that performs standard allocation, i.e., memory allocation.

Similarly, the standard delete expression in C++ internally calls the standard operator delete(), which is defined as follows:

void operator delete (void *) throw();

operator delete() is also an operator or function that performs standard deallocation, i.e., memory release.

Placement new and placement delete

The standard new expression in C++ can fulfill most needs, but not all. For example, how to create an object in existing memory space cannot be done with the standard new expression, and C++ does not support directly calling an object’s constructor in raw memory. Thus, placement new was created, named placement, which also indicates its historical origin, that is, to construct a new object in place.

Of course, creating objects in place is just one part; placement new has a broader extension, and both placement new expression and placement operator new() are generally referred to as placement new, which confuses the concepts.

What is placement operator new()? It is primarily a function and an overloaded version of the standard operator new(). Wiki defines it as follows:

The “placement” versions of the new and delete operators and functions are known as placement new and placement delete.

What is placement new expression? It belongs to C++ syntax, similar to the standard new expression, but internally calls the corresponding placement operator new(). Wiki defines it as follows:

Any new expression that uses the placement syntax is a placement new expression.

Just as the standard new expression calls the standard operator new(), the placement new expression calls the placement version of the operator new(). It seems straightforward, but when mixed together, it doesn’t seem to be a problem. However, consider placement delete, which indicates the placement operator delete() function, because there is fundamentally no placement delete expression. When we call

delete pObject;

we are calling the standard operator delete(). Why is there no placement delete expression? The creators of C++ explained:

The reason that there is no built-in “placement delete” to match placement new is that there is no general way of assuring that it would be used correctly.

Since there is no placement delete expression, why do we still need placement operator delete()? An important reason is that C++ requires placement <code>operator delete()<code> and placement <code>operator new() to be paired. Suppose a situation arises:

When you call the placement new expression to construct an object, and an exception is thrown in the constructor, what should be done? C++ can only call the corresponding placement operator delete()<code>, to release the memory resources obtained by placement <code>operator new(), otherwise, there will be a memory leak. You can feel this through the following example:

#include <cstdlib>
#include <iostream>

struct A {} ;
struct E {} ;

class T {
public:
    T() { throwE() ; }
} ;

void * operator new ( std::size_t, const A & )
    {std::cout << "Placement new called." << std::endl;}
void operator delete ( void *, const A & )
    {std::cout << "Placement delete called." << std::endl;}

int main ()
{
    A a ;
    try {
        T * p = new (a) T ;
    } catch (E exp) {std::cout << "Exception caught." << std::endl;}
    return0 ;
}

Placement operator new() and placement operator delete()

The above only defines the difference between expression and operator. What kind of function qualifies as placement operator new() and placement operator delete()? They differ from the standard operator new() and operator delete()<code> by adding custom parameters. However, they must adhere to the following rules.

For placement operator new(), its first function parameter must be std::size_t, indicating the size of the memory to be allocated; for placement operator delete(), its first function parameter must be void *, indicating the pointer to the object to be released. For example:

void * operator new (std::size_t) throw(std::bad_alloc);    // Standard version
void * operator new (std::size_t, const std::nothrow_t &) throw(); // Placement version
void operator delete (void *) throw(); // Standard version
void operator delete (void *, const std::nothrow_t &) throw(); // Placement version

Note that the nothrow version of new is also part of the C++ standard, which is implemented through placement new and placement delete. The corresponding nothrow version of the new expression is as follows:

T *t = new(std::nothrow) T;

Constructing objects in user-defined space is the original intention of placement new, and it has also been included in the C++ standard as the default placement:

void * operator new (std::size_t, void * p) throw() { return p ; }
void operator delete (void *, void *) throw() { }

The corresponding placement new expression is used like this:

void *buffer = malloc(sizeof(ClassA));
ClassA *ptr = new(buffer)ClassA();

Placement new used in Memory Pool

In practical applications, memory pools are used the most, which is worth mentioning. Suppose a memory pool is defined as follows:

class Arena {
public:
    void* allocate(size_t);
    void deallocate(void*);
    // ...
};

By defining placement new and placement delete for the Arena class:

void* operator new(size_t sz, Arena& a)
{
    return a.allocate(sz);
}
void operator delete(void *ptr, Arena& a)
{
    return a.deallocate(ptr);
}

Creating an object:

Arena a();
X *p = new(a)X;

The current issue is how to delete, because we cannot call

delete p;

This would only invoke the standard operator delete(), not the placement version for Arena. Therefore, we can only do this:

p->~X();
operator delete(p, a);

Or encapsulate the two operations into a template:

    template<class T> void destroy(T* p, Arena& a)
    {
        if (p) {
             p->~T();       // explicit destructor call
             a.deallocate(p);
        }
    }

Then call it like this:

destroy(p,a);