Когда я должен использовать новое ключевое слово в C ++?

Question

Я давно пользуюсь C ++, и меня интересует ключевое слово new . Просто я должен использовать это или нет?

1) С ключевым словом new ...

MyClass* myClass = new MyClass();
myClass->MyField = "Hello world!";

2) Без ключевого слова new ...

MyClass myClass;
myClass.MyField = "Hello world!";

С точки зрения реализации, они не кажутся такими уж разными (но я уверен, что это так) ... Однако мой основной язык - C #, и, конечно, я привык к 1-му методу.

Сложность заключается в том, что метод 1 сложнее использовать с классами std C ++.

Какой метод я должен использовать?

Обновление 1:

Недавно я использовал ключевое слово new для heap memory (или free store ) для большого массива, который выходил из области видимости (т.е. возвращался из функция). Если раньше я использовал стек, что приводило к повреждению половины элементов вне области видимости, переключение на использование кучи гарантировало, что элементы были в такте. Ура!

Обновление 2:

Мой друг недавно сказал мне, что есть простое правило для использования ключевого слова new; каждый раз, когда вы набираете new, введите delete.

Foobar *foobar = new Foobar();
delete foobar; // TODO: Move this to the right place.

Это помогает предотвратить утечки памяти, поскольку вы всегда должны куда-то помещать удаление (т. Е. Когда вы вырезаете и вставляете его либо в деструктор, либо в другое место).

Answer 1

Метод 1 (с использованием new)

• Выделяет память для объекта в бесплатном хранилище (Это часто то же самое, что и heap )
• Требует от вас явного delete вашего объекта позже. (Если вы не удалите его, вы можете создать утечку памяти)
• Память остается выделенной, пока вы не delete ее. (т.е. вы могли бы return объект, который вы создали с помощью new)
• Пример в вопросе будет утечка памяти , если указатель не равен delete d; и всегда следует удалять , независимо от того, какой путь управления выбран, или если генерируются исключения.

Метод 2 (не используется new)

• Выделяет память для объекта в стеке (куда идут все локальные переменные) Как правило, для стека доступно меньше памяти; если вы выделяете слишком много объектов, вы рискуете переполнить стек.
• Вам не нужно будет delete позже.
• Память больше не выделяется, когда она выходит из области видимости. (т.е. вы не должны return указатель на объект в стеке)

Насколько использовать; Вы выбираете метод, который работает лучше всего для вас, учитывая вышеупомянутые ограничения.

Некоторые простые случаи:

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

Answer 2

Между ними есть важное различие.

Все, что не выделено с помощью new, ведет себя во многом как типы значений в C # (и люди часто говорят, что эти объекты размещаются в стеке, что, вероятно, является наиболее распространенным / очевидным случаем, но не всегда верно. Точнее, объекты выделены без использования new имеют длительность автоматического хранения Все, выделенное с помощью new, размещается в куче, и возвращается указатель на него, точно так же, как ссылочные типы в C #.

Все, что размещено в стеке, должно иметь постоянный размер, определенный во время компиляции (компилятор должен правильно установить указатель стека или, если объект является членом другого класса, он должен настроить размер этого другой класс). Вот почему массивы в C # являются ссылочными типами. Они должны быть, потому что со ссылочными типами мы можем решить во время выполнения, какой объем памяти запрашивать. И то же самое здесь. Только массивы с постоянным размером (размер, который может быть определен во время компиляции) могут быть распределены с автоматической продолжительностью хранения (в стеке). Массивы динамического размера должны быть размещены в куче, вызывая new.

(И на этом сходство с C # прекращается)

Теперь все, что размещено в стеке, имеет «автоматическую» продолжительность хранения (вы можете объявить переменную как auto, но это значение по умолчанию, если не указан другой тип хранилища, поэтому ключевое слово действительно не используется на практике. , но это откуда)

Длительность автоматического хранения означает, как именно это звучит, продолжительность переменной обрабатывается автоматически. Напротив, все, что размещено в куче, должно быть удалено вами вручную. Вот пример:

void foo() {
  bar b;
  bar* b2 = new bar();
}

Эта функция создает три значения, которые следует учитывать:

В строке 1 объявляется переменная b типа bar в стеке (автоматическая продолжительность).

В строке 2 объявляется указатель bar b2 в стеке (автоматическая длительность), и вызывает new, выделяя объект bar в куче. (динамическая продолжительность)

Когда функция вернется, произойдет следующее: Во-первых, b2 выходит за рамки (порядок уничтожения всегда противоположен порядку построения). Но b2 - просто указатель, поэтому ничего не происходит, занимаемая им память просто освобождается. И что важно, память, на которую она указывает (экземпляр bar в куче) НЕ затрагивается. Только указатель освобождается, потому что только указатель имел автоматическую продолжительность. Во-вторых, b выходит из области видимости, поэтому, поскольку он имеет автоматическую продолжительность, вызывается его деструктор и освобождается память.

А экземпляр bar в куче? Это, вероятно, все еще там. Никто не удосужился удалить его, поэтому мы вытекли из памяти.

Из этого примера мы видим, что для всего с автоматической продолжительностью гарантируется , что его деструктор будет вызываться при выходе из области видимости. Это полезно Но все, что размещено в куче, длится столько времени, сколько нам нужно, и может иметь динамический размер, как в случае массивов. Это тоже полезно. Мы можем использовать это для управления распределением памяти. Что если класс Foo выделил некоторую память в куче в своем конструкторе и удалил эту память в своем деструкторе. Тогда мы могли бы получить лучшее из обоих миров - безопасное распределение памяти, которое гарантированно будет освобождено снова, но без ограничений, заставляющих все быть в стеке.

И именно так работает большинство кодов C ++. Посмотрите на стандартную библиотеку std::vector например. Это обычно выделяется в стеке, но может иметь динамический размер и размер. И делает это путем внутреннего распределения памяти в куче по мере необходимости. Пользователь этого класса никогда не увидит этого, поэтому нет шансов утечь память или забыть очистить то, что вы выделили.

Этот принцип называется RAII (Resource Acquisition is Initialization), и его можно распространить на любой ресурс, который необходимо получить и освободить. (сетевые сокеты, файлы, соединения с базой данных, блокировки синхронизации). Все они могут быть получены в конструкторе и выпущены в деструкторе, так что вы гарантированно, что все приобретенные вами ресурсы будут снова освобождены.

Как правило, никогда не используйте new / delete напрямую из кода высокого уровня. Всегда оборачивайте его в класс, который может управлять памятью для вас и который обеспечит ее освобождение снова. (Да, могут быть исключения из этого правила. В частности, умные указатели требуют, чтобы вы вызывали new напрямую и передавали указатель на его конструктор, который затем вступает во владение и гарантирует, что delete вызывается правильно. очень важное правило)

Answer 3

Какой метод я должен использовать?

Это почти никогда не определяется вашими предпочтениями, а контекстом. Если вам нужно поместить объект в несколько стеков или он слишком тяжел для стека, вы размещаете его в бесплатном хранилище. Кроме того, поскольку вы выделяете объект, вы также несете ответственность за освобождение памяти. Поиск оператора delete.

Чтобы облегчить бремя использования управления свободными магазинами, люди изобрели такие вещи, как auto_ptr и unique_ptr. Я настоятельно рекомендую вам взглянуть на это. Они могут даже помочь в ваших проблемах с печатанием; -)

Answer 4

Если вы пишете на C ++, вы, вероятно, пишете для производительности. Использование new и бесплатного хранилища намного медленнее, чем использование стека (особенно при использовании потоков), поэтому используйте его только тогда, когда вам это нужно.

Как уже говорили другие, вам нужно новое, когда ваш объект должен находиться вне функции или области видимости объекта, объект действительно большой или когда вы не знаете размер массива во время компиляции.

Кроме того, старайтесь никогда не использовать delete. Вместо этого оберните ваш новый в умный указатель. Позвольте интеллектуальному указателю вызвать удаление для вас.

В некоторых случаях умный указатель не является умным. Никогда не храните std :: auto_ptr <> внутри контейнера STL. Он удалит указатель слишком рано из-за операций копирования внутри контейнера. Другой случай, когда у вас есть действительно большой контейнер указателей STL на объекты. У boost :: shared_ptr <> будет тонна накладных расходов на скорость, поскольку она увеличивает счетчик ссылок вверх и вниз. В этом случае лучше всего поместить контейнер STL в другой объект и дать этому объекту деструктор, который будет вызывать delete для каждого указателя в контейнере.

Answer 5

Короткий ответ: если вы новичок в C ++, вы никогда не должны использовать new или delete самостоятельно.

Вместо этого вы должны использовать умные указатели, такие как std::unique_ptr и std::make_unique (или реже, std::shared_ptr и std::make_shared). Таким образом, вам не придется беспокоиться о утечках памяти. И даже если вы более продвинуты, обычно рекомендуется заключать инкапсулированный пользовательский способ использования new и delete в небольшой класс (например, настраиваемый интеллектуальный указатель), предназначенный только для решения проблем жизненного цикла объекта. .

Конечно, негласно, эти интеллектуальные указатели все еще выполняют динамическое выделение и освобождение, поэтому код, использующий их, все равно будет иметь связанные с этим издержки времени выполнения. Другие ответы здесь касались этих проблем и того, как принимать решения о том, когда использовать интеллектуальные указатели, а не просто создавать объекты в стеке или включать их в качестве непосредственных членов объекта, достаточно хорошо, чтобы я не повторял их. Но мое резюме будет таким: не используйте умные указатели или динамическое распределение, пока что-то не заставит вас.

Answer 6

Без ключевого слова new это сохраняется в стеке вызовов . Хранение слишком больших переменных в стеке приведет к переполнению стека .

Answer 7

Если ваша переменная используется только в контексте одной функции, вам лучше использовать переменную стека, т. Е. Вариант 2. Как уже говорили другие, вам не нужно управлять временем жизни переменных стека - они построены и уничтожены автоматически. Кроме того, распределение / освобождение переменной в куче является медленным по сравнению. Если ваша функция вызывается достаточно часто, вы увидите огромное улучшение производительности, если использовать переменные стека по сравнению с переменными кучи.

Тем не менее, есть несколько очевидных случаев, когда переменные стека недостаточны.

Если переменная стека имеет большой объем памяти, то вы рискуете переполнить стек. По умолчанию размер стека каждого потока составляет 1 МБ в Windows. Маловероятно, что вы создадите переменную стека размером 1 МБ, но вы должны помнить, что использование стека является кумулятивным. Если ваша функция вызывает функцию, которая вызывает другую функцию, которая вызывает другую функцию, которая ..., переменные стека во всех этих функциях занимают место в одном стеке. Рекурсивные функции могут быстро столкнуться с этой проблемой, в зависимости от глубины рекурсии. Если это проблема, вы можете увеличить размер стека (не рекомендуется) или выделить переменную в куче, используя оператор new (рекомендуется).

Другое, более вероятное условие - ваша переменная должна «жить» за пределами вашей функции. В этом случае вы должны разместить переменную в куче так, чтобы она могла быть достигнута за пределами любой заданной функции.

Answer 8

Вы передаете myClass из функции или ожидаете, что он будет существовать вне этой функции? Как говорили некоторые другие, все дело в области видимости, когда вы не выделяете кучу. Когда вы покидаете функцию, она исчезает (в конце концов). Одна из классических ошибок новичков - попытка создать локальный объект некоторого класса в функции и вернуть его, не размещая его в куче. Я помню, как отлаживал подобные вещи в мои ранние дни, занимаясь с ++.

Answer 9

Простой ответ - да - new () создает объект в куче (с нежелательным побочным эффектом, который вы должны управлять его временем жизни (явно вызывая delete для него), тогда как вторая форма создает объект в стеке в текущей области, и этот объект будет уничтожен, когда он выйдет из области видимости.

Answer 10

Второй метод создает экземпляр в стеке вместе с такими вещами, как что-то объявленное int и список параметров, которые передаются в функцию.

Первый метод освобождает место для указателя в стеке, для которого вы указали место в памяти, где в куче или в свободном хранилище было выделено новое MyClass.

Первый метод также требует от вас delete того, что вы создаете с помощью new, тогда как во втором методе класс автоматически уничтожается и освобождается, когда он выходит из области видимости (обычно следующая закрывающая скобка).