Почему программистам на C++ стоит минимизировать использование `new`?

Ключевая проблема: явное управление ресурсами

Ваше замешательство совершенно естественно. Проблема не в самом new, а в том, что он заставляет вас вручную управлять временем жизни объекта. В современном C++ (C++11 и новее) принят подход RAII (Resource Acquisition Is Initialization), который автоматизирует эту задачу.

Вот почему new опасен:

• Утечки памяти — вы забыли delete, и память не освобождается.
• Исключения — если после new до delete вылетит исключение, память утечет.
• Сложность кода — нужно помнить, где и когда вызывать delete, особенно при множественных точках выхода из функции.
• Двойное удаление — случайный вызов delete для одного указателя дважды приводит к неопределенному поведению.

Решение: умные указатели и стек

В 99% случаев вам не нужен сырой new. Используйте:

1. Стек — если объект живет только внутри функции.
2. std::unique_ptr — если объект должен жить дольше функции и у него единственный владелец.
3. std::shared_ptr — если у объекта несколько владельцев.

Перепишем ваш пример правильно:

#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "Создан\n"; }
    ~MyClass() { std::cout << "Уничтожен\n"; }
    void doWork() { /* ... */ }
};

void process() {
    // Вариант 1: объект на стеке (если не нужно возвращать)
    MyClass obj;
    obj.doWork();
    // obj автоматически уничтожится при выходе из функции

    // Вариант 2: умный указатель (если нужно передать наружу)
    auto ptr = std::make_unique<MyClass>();
    ptr->doWork();
    // ptr автоматически удалится, когда выйдет из области видимости
}

std::unique_ptr<MyClass> createObject() {
    // Создаем объект и передаем владение вызывающему коду
    return std::make_unique<MyClass>();
}

Почему это лучше?

• Автоматическое освобождение — умные указатели вызывают delete при уничтожении (RAII).
• Исключения — если вылетит исключение, умный указатель сам удалит объект.
• Чистый код — вы не думаете о ручном управлении памятью.
• Производительность — стек быстрее кучи, а std::make_unique избегает лишнего копирования.

Когда new все-таки нужен?

Только в низкоуровневом коде: реализация собственного аллокатора, работа с C-библиотеками, которые требуют сырых указателей. Но даже в этих случаях сырой new оборачивается в умный указатель сразу после выделения.

Запомните правило: если вы пишете new, вы должны сразу же передать результат в умный указатель. В современном C++ это делается через std::make_unique или std::make_shared, которые скрывают new внутри себя.

В итоге: минимизация new — это не прихоть, а способ писать более безопасный, понятный и поддерживаемый код. Используйте стек по умолчанию, умные указатели при необходимости, и забудьте о ручном delete.

MyClass* arr = new MyClass[10]; // ручное управление
delete[] arr; // легко забыть

#include <vector>

std::vector<MyClass> vec(10); // автоматическое управление
// vec уничтожится сам при выходе из области видимости

void foo(MyClass* p);
foo(new MyClass()); // утечка при исключении в foo

void foo(std::unique_ptr<MyClass> p);
foo(std::make_unique<MyClass>()); // безопасно

void foo(MyClass& p);
MyClass obj;
foo(obj); // никакого new не нужно