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

Почему `new` — это зло в современном C++

Отличный вопрос! Ты попал в самую точку. Разница между Java и C++ в управлении памятью — одна из самых частых ловушек для новичков. Давай разберёмся по порядку.

В Java new — это единственный способ создать объект. В C++ же есть два принципиально разных способа: стек (автоматическое хранение) и куча (динамическое хранение). И вот почему стек лучше в 90% случаев:

1. Автоматическое управление временем жизни

Объекты на стеке уничтожаются автоматически при выходе из области видимости. Это исключает утечки памяти. Сравни:

// Плохо: ручное управление
void bad() {
    Person* p = new Person("Alice");
    p->greet();
    delete p; // Если забыть — утечка, если вызвать дважды — UB
}

// Хорошо: автоматическое управление
void good() {
    Person p("Alice");  // На стеке
    p.greet();
} // p автоматически уничтожается здесь

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

Выделение памяти на стеке — это просто сдвиг указателя стека (O(1)). Выделение в куче через new — это сложный системный вызов с поиском свободного блока. Плюс фрагментация памяти.

3. Исключения и безопасность

При использовании new и исключениях легко получить утечку:

void risky() {
    Person* p = new Person("Alice");
    doSomething(); // Если бросит исключение — утечка!
    delete p;
}

Когда же нужен `new`?

Есть всего несколько сценариев, где динамическое выделение оправдано:

• Размер объекта неизвестен во время компиляции (например, массивы переменной длины в старом стандарте).
• Объект должен жить дольше, чем создавшая его функция (например, фабрики).
• Полиморфные объекты в контейнерах (но и тут есть решение умнее).

Правильный подход: RAII и умные указатели

В современном C++ (C++11 и новее) вместо голого new используй умные указатели. Они автоматически вызывают delete:

#include <memory>

// Вместо Person* p = new Person("Alice");
std::unique_ptr<Person> p = std::make_unique<Person>("Alice");
// delete вызывается автоматически при выходе из области видимости

// Если нужно разделяемое владение:
std::shared_ptr<Person> sp = std::make_shared<Person>("Bob");
// Удалится, когда последний shared_ptr будет уничтожен

Исправленный пример из вопроса

#include <iostream>
#include <string>
#include <memory>
#include <vector>

class Person {
public:
    Person(const std::string& name) : name_(name) {
        std::cout << "Created: " << name_ << std::endl;
    }
    ~Person() {
        std::cout << "Destroyed: " << name_ << std::endl;
    }
    void greet() const { std::cout << "Hello, I'm " << name_ << std::endl; }
private:
    std::string name_;
};

void processPerson(const Person& p) {
    p.greet();
}

int main() {
    // Вариант 1: на стеке (рекомендуется)
    Person p1("Alice");
    processPerson(p1);  // Передаём по ссылке — без копирования
    
    // Вариант 2: если нужна куча — умный указатель
    auto p2 = std::make_unique<Person>("Bob");
    processPerson(*p2);  // Разыменовываем умный указатель
    
    // Вариант 3: вектор объектов (без new!)
    std::vector<Person> people;
    people.emplace_back("Charlie"); // Создаётся прямо в векторе
    people.emplace_back("Diana");
    
    for (const auto& person : people) {
        person.greet();
    }
    // Все объекты уничтожатся автоматически при выходе из main
    
    return 0;
}

Вывод: В 95% случаев тебе не нужен сырой new. Используй стековые объекты, умные указатели или контейнеры STL. Это сделает код безопаснее, быстрее и понятнее.

#include <memory>
#include <vector>

class Shape {
public:
    virtual void draw() const = 0;
    virtual ~Shape() = default; // Важно для умных указателей
};

class Circle : public Shape {
    void draw() const override { /* ... */ }
};

class Square : public Shape {
    void draw() const override { /* ... */ }
};

// Правильный подход: вектор умных указателей
std::vector<std::unique_ptr<Shape>> shapes;
shapes.push_back(std::make_unique<Circle>());
shapes.push_back(std::make_unique<Square>());

for (const auto& s : shapes) {
    s->draw(); // Полиморфный вызов
}
// Вся память очистится автоматически

auto ptr = std::make_unique<Person>("Alice");
old_library_function(ptr.get()); // Передаём сырой указатель
// ptr автоматически удалит объект после вызова