Лучше использовать переменные кучи или стека?

В зависимости от контекста мы можем рассматривать кучу или стек. Каждый поток получает стек, и поток выполняет инструкции, вызывая функции. Когда функция вызывается, переменные функции помещаются в стек. И когда функция возвращает откат стека и память восстанавливается. Теперь существует ограничение на размер локального стека потока, оно варьируется и может быть изменено в некоторой степени. Учитывая это, если каждый объект создается в стеке и объекту требуется большой объем памяти, то пространство стека будет исчерпано, что приведет к ошибке переполнения стека. Кроме того, если к объекту должны обращаться несколько потоков, то хранение такого объекта в стеке не имеет смысла.

Таким образом, небольшие переменные, небольшие объекты, размер которых можно определить во время компиляции, и указатели должны храниться в стеке. Проблема хранения объектов в куче или в свободном хранилище заключается в том, что управление памятью становится затруднительным. Есть вероятность утечки памяти, что плохо. Также, если приложение попытается получить доступ к объекту, который уже удален, может произойти нарушение прав доступа, что может привести к сбою приложения.

В C++11 представлены интеллектуальные указатели (общие, уникальные), упрощающие управление памятью с кучей. Фактический ссылочный объект находится в куче, но инкапсулируется интеллектуальным указателем, который всегда находится в стеке. Следовательно, когда стек откатывается во время события возврата функции или во время исключения, деструктор интеллектуального указателя удаляет фактический объект в куче. В случае общего указателя счетчик ссылок сохраняется, а фактический объект удаляется, когда счетчик ссылок равен нулю. http://en.wikipedia.org/wiki/Smart_pointer

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

На самом деле время жизни объекта, созданного в стеке и в куче, разное:

• Локальные переменные функции или блока кода {} (не выделенные new) находятся в стеке. Они автоматически уничтожаются, когда вы возвращаетесь из функции. (вызываются их деструкторы и освобождается их память).
• Но если вам нужен какой-то объект, который будет использоваться вне функции, вам придется выделить его в куче (используя new) или вернуть копию.

Пример:

 void myFun()
 {
   A onStack; // On the stack
   A* onHeap = new A(); // On the heap
   // Do things...

 } // End of the function onStack is destroyed, but the &onHeap is still alive

В этом примере onHeap по-прежнему будет выделена память, когда функция завершится. Таким образом, если у вас где-то нет указателя на onHeap, вы не сможете его удалить и освободить память. Это утечка памяти, так как память будет потеряна до конца программы.

Однако если бы вы вернули указатель на onStack, поскольку onStack был уничтожен при выходе из функции, использование указателя могло бы привести к неопределенному поведению. При использовании onHeap по-прежнему действует.

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

Не существует общих правил относительно использования переменных, выделенных в стеке, и переменных, выделенных в куче. Есть только рекомендации, в зависимости от того, что вы пытаетесь сделать.

Вот некоторые плюсы и минусы:

Распределение кучи:

Плюсы:

• более гибкий - на случай, если у вас много информации, недоступной во время компиляции
• больше по размеру - вы можете выделить больше - однако это не бесконечно, поэтому в какой-то момент вашей программе может не хватить памяти, если выделение/освобождение не обрабатывается правильно

Минусы:

• медленнее — динамическое выделение обычно медленнее, чем стековое.
• может вызвать фрагментацию памяти - выделение и освобождение объектов разных размеров сделает память похожей на швейцарский сыр :), что приведет к сбою некоторых выделений, если нет доступного блока памяти требуемого размера
• сложнее поддерживать - как вы знаете, за каждым динамическим выделением должно следовать освобождение, которое должен выполнять пользователь - это подвержено ошибкам, так как во многих случаях люди забывают сопоставить каждый вызов malloc() с free( ) вызов или new() с помощью delete()

Распределение стека:

Плюсы:

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

Минусы:

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

Я думаю, что это отражает некоторые плюсы и минусы. Я уверен, что есть и другие.

В конце концов, это зависит от того, что нужно вашему приложению.

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

Так что на самом деле это должны быть лошади для курсов, но если у вас есть выбор, всегда избегайте переменных, выделенных кучей.

Ответ не так однозначен, как некоторые заставляют вас поверить.

В общем, вы должны предпочесть автоматические переменные (в стеке), потому что это просто проще. Однако в некоторых ситуациях требуется динамическое выделение (в куче):

• неизвестный размер во время компиляции
• расширяемый (контейнеры используют выделение кучи внутри)
• большие объекты

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

Лично я использую следующий принцип:

• локальные объекты выделяются автоматически
• локальные массивы откладываются до std::vector<T>, который динамически распределяет их внутри

это сослужило мне хорошую службу (что, очевидно, является просто анекдотичным свидетельством).

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

C++ не упоминает кучу или стек. Что касается языка, то они не существуют/не являются отдельными вещами.

Что касается практического ответа - используйте то, что работает лучше всего - вам нужно быстро - вам нужны гарантии. Приложение A может быть намного лучше со всем, что находится в куче, приложение B может так сильно фрагментировать память ОС, что это убьет машину - правильного ответа нет :-(

Проще говоря, не управляйте собственной памятью без необходимости. ;)

Стек = статические данные, выделенные во время компиляции. (не динамический)

Куча = динамические данные, выделенные во время выполнения. (Очень динамично)

Хотя указатели находятся в стеке... Эти указатели прекрасны, потому что они открывают двери для динамического, спонтанного создания данных (в зависимости от того, как вы кодируете свою программу).

(Но я просто дикарь, так какая разница, что я говорю)