Что такое placement new?

Placement New: конструирование объектов в предвыделенной памяти

Placement new — это продвинутая техника C++, которая позволяет создавать (конструировать) объекты в уже выделенной памяти, вместо выделения новой памяти. Это не выделяет новую память, а вызывает конструктор объекта в уже существующей области памяти.

Основная синтаксис

// Обычный new — выделяет память И вызывает конструктор
MyClass* obj = new MyClass(args);

// Placement new — вызывает конструктор в существующей памяти
MyClass* obj = new (ptr) MyClass(args);  // ptr — адрес памяти

Практический пример 1: Использование стека

class Point {
public:
    int x, y;
    Point(int x = 0, int y = 0) : x(x), y(y) {
        std::cout << "Constructor called\n";
    }
    ~Point() {
        std::cout << "Destructor called\n";
    }
};

int main() {
    // Выделяем память на стеке (не вызывая конструктор!)
    char buffer[sizeof(Point)];
    
    // Используем placement new для конструирования в этой памяти
    Point* p = new (buffer) Point(10, 20);  // Конструктор вызван!
    
    std::cout << "x=" << p->x << ", y=" << p->y << "\n";
    
    // ВАЖНО: деструктор вызывается вручную!
    p->~Point();  // Явно вызываем деструктор
    
    return 0;  // buffer автоматически удаляется (это стек)
}

Пример 2: Переиспользование памяти

class MyObject {
public:
    int value;
    MyObject(int v) : value(v) { std::cout << "Constructed\n"; }
    ~MyObject() { std::cout << "Destructed\n"; }
};

int main() {
    // Одна область памяти для нескольких объектов
    char memory[sizeof(MyObject) * 3];
    
    // Конструируем три объекта в одной области
    MyObject* obj1 = new (memory + 0 * sizeof(MyObject)) MyObject(1);
    MyObject* obj2 = new (memory + 1 * sizeof(MyObject)) MyObject(2);
    MyObject* obj3 = new (memory + 2 * sizeof(MyObject)) MyObject(3);
    
    obj1->~MyObject();
    obj2->~MyObject();
    obj3->~MyObject();
    
    return 0;
}

Пример 3: Пул объектов (Object Pool)

Одно из главных применений placement new — оптимизация производительности:

template<typename T>
class ObjectPool {
private:
    std::vector<char> buffer;
    std::queue<T*> available;
    std::vector<T*> all;
    size_t object_size;

public:
    ObjectPool(size_t capacity = 1000) {
        object_size = sizeof(T);
        buffer.resize(capacity * object_size);
        
        // Предвыделяем все объекты
        for (size_t i = 0; i < capacity; ++i) {
            char* ptr = buffer.data() + i * object_size;
            T* obj = new (ptr) T();  // Placement new!
            available.push(obj);
            all.push_back(obj);
        }
    }
    
    T* acquire() {
        if (available.empty()) return nullptr;
        T* obj = available.front();
        available.pop();
        return obj;
    }
    
    void release(T* obj) {
        obj->reset();  // Сбрасываем состояние
        available.push(obj);
    }
    
    ~ObjectPool() {
        for (auto obj : all) {
            obj->~T();  // Вызываем деструктор вручную
        }
    }
};

// Использование
class Connection {
public:
    void reset() { /* очистить состояние */ }
};

int main() {
    ObjectPool<Connection> pool(1000);
    
    // Вместо new/delete используем pool
    Connection* conn = pool.acquire();
    // ... работа с conn
    pool.release(conn);  // Очень быстро!
    
    return 0;
}

Пример 4: Ring Buffer для сетевых данных

template<typename T, size_t N>
class RingBuffer {
private:
    alignas(64) char buffer[N * sizeof(T)];  // Выровняно для cache-line
    size_t read_pos = 0;
    size_t write_pos = 0;

public:
    void push(const T& value) {
        if (isFull()) return;
        
        T* ptr = reinterpret_cast<T*>(buffer + write_pos * sizeof(T));
        new (ptr) T(value);  // Placement new
        write_pos = (write_pos + 1) % N;
    }
    
    T pop() {
        if (isEmpty()) throw std::runtime_error("Empty");
        
        T* ptr = reinterpret_cast<T*>(buffer + read_pos * sizeof(T));
        T value = *ptr;
        ptr->~T();  // Явный деструктор
        read_pos = (read_pos + 1) % N;
        return value;
    }
    
    bool isFull() const { return (write_pos + 1) % N == read_pos; }
    bool isEmpty() const { return read_pos == write_pos; }
};

Преимущества placement new

1. Производительность

• Избегаем динамического выделения памяти (malloc/new)
• Минимизируем heap fragmentation
• Идеально для real-time систем с predictable latency

2. Контроль памяти

// Можем выделить память один раз и переиспользовать
char* pool = new char[1000000];
// ... создаём тысячи объектов в этом буфере
delete[] pool;  // Один delete для всех!

3. Cache efficiency

• Можем выровнять память по cache-line
• Улучшаем cache locality

alignof(64) char buffer[1000];  // Выровнено по 64-байт границе

Когда использовать placement new

Используй placement new для:

• Object pools — когда часто создаёшь/удаляешь одинаковые объекты
• Ring buffers — в сетевых приложениях для обработки пакетов
• Real-time системы — когда нужна предсказуемая задержка (no GC паузы)
• Встроенные системы — когда нельзя выделить память динамически
• High-performance computing — когда нужен precise memory layout

НЕ используй placement new если:

• Не нужна экстремальная оптимизация
• Можешь использовать std::vector или smart pointers
• Управление памятью становится сложным и подвержено ошибкам

Опасности placement new

1. Забывчивость с деструктором

// ❌ ОШИБКА — утечка ресурсов, деструктор не вызван!
Point* p = new (buffer) Point(1, 2);
// ... buffer уходит из scope без p->~Point()

// ✅ Правильно
Point* p = new (buffer) Point(1, 2);
p->~Point();  // Явный вызов

2. Забывчивость про exception safety

char buffer[sizeof(MyClass)];
MyClass* obj = new (buffer) MyClass();  // Может выбросить исключение!
// Если выбросит, buffer останется в плохом состоянии

3. Сложность с наследованием и виртуальными методами

// ⚠️ Осторожно с наследованием!
class Base { virtual ~Base() {} };
class Derived : public Base { /* ... */ };

char buffer[sizeof(Derived)];
Base* b = new (buffer) Derived();  // Может вызвать проблемы

Итог

Placement new — это мощный инструмент для оптимизации памяти и производительности, но требует осторожности и дополнительного кода для управления деструкторами. Это инструмент профессионалов, используется в системном программировании, высоконагруженных приложениях и embedded системах. Для большинства приложений рекомендуется использовать RAII и smart pointers, но знание placement new критично для Backend разработчика C++.