Почему в C++ лучше передавать объекты по указателю, а не по значению?

Понимание разницы: объект по значению vs указатель

Отличный вопрос! Ваше замешательство абсолютно нормально для разработчика, переходящего с Java на C++. Ключевое различие в том, как C++ управляет памятью и временем жизни объектов.

Когда вы пишете MyClass obj;, вы создаете объект на стеке. Он живет ровно до конца своей области видимости. Когда вы передаете его в функцию по значению, как в вашем первом примере, происходит копирование всего объекта. Функция работает с копией, оригинал не изменяется. Это называется семантика значений (value semantics).

Когда вы пишете MyClass* obj = new MyClass();, вы создаете объект в куче. Он будет жить, пока вы явно не вызовете delete. Указатель — это просто адрес в памяти. Передавая указатель, вы даете функции доступ к оригинальному объекту, а не к его копии.

Когда использовать объекты по значению?

• Маленькие объекты (int, double, Point, Color) — копирование дешево и эффективно.
• Когда объект не должен изменяться внутри функции — передача по константной ссылке const MyClass& data.
• Когда объект является владельцем ресурсов и должен быть автоматически уничтожен при выходе из области видимости (RAII).
• Для простоты и безопасности — нет риска утечки памяти или висячих указателей.

Когда использовать указатели?

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

Правильный подход с современным C++

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

// Передача по значению (копирование)
void processByValue(MyClass data) {
    data.setValue(42);
}

// Передача по ссылке (изменение оригинала)
void processByReference(MyClass& data) {
    data.setValue(42);
}

// Передача по константной ссылке (только чтение)
void processByConstRef(const MyClass& data) {
    int val = data.getValue(); // можно читать
    // data.setValue(42); // ОШИБКА: константная ссылка
}

// Современный подход с умными указателями
#include <memory>

void processWithUnique(std::unique_ptr<MyClass>& data) {
    data->setValue(42);
}

int main() {
    // Вариант 1: объект на стеке
    MyClass obj1;
    processByReference(obj1); // ok, obj1 изменен
    
    // Вариант 2: объект в куче через unique_ptr
    auto obj2 = std::make_unique<MyClass>();
    processWithUnique(obj2);
    // delete не нужен — unique_ptr сам очистит память
    
    // Вариант 3: разделяемое владение
    auto obj3 = std::make_shared<MyClass>();
    // obj3 можно безопасно копировать между функциями
    
    return 0;
}

Золотое правило

1. По умолчанию используйте объекты по значению или константные ссылки.
2. Если нужно изменить — используйте ссылку (&), а не указатель.
3. Если нужен полиморфизм или опциональность — используйте умные указатели.
4. Избегайте new/delete вручную в современном коде.

void processData(MyClass* data) {
    // Что если data == nullptr?
    data->setValue(42); // Программа упадет!
}

int main() {
    MyClass* obj = nullptr;
    processData(obj); // Ошибка сегментации
    return 0;
}

void processData(MyClass& data) {
    data.setValue(42); // Безопасно
}

int main() {
    MyClass obj;
    processData(obj); // Работает, obj изменен
    return 0;
}