Как переменные размещаются в памяти компьютера

Обновлено: 21.11.2024

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

Как переменным выделяется память в C?

Статическое размещение — это то, что происходит, когда вы объявляете статическую или глобальную переменную. .
Автоматическое выделение происходит при объявлении автоматической переменной, например аргумента функции или локальной переменной.

Когда следует выделять память в C?

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

Что происходит в памяти, когда вы объявляете переменную?

Когда вы объявляете переменную в файле . NET, он выделяет часть памяти в ОЗУ. . Это было простое объяснение того, что происходит в памяти, но в зависимости от типа данных вашей переменной выделяется этот тип памяти. Существует два типа распределения памяти: память стека и память кучи.

Где выделяется память для локальной переменной?

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

Динамическое выделение памяти | Учебник по языку Си

Найдено 42 похожих вопроса

Как переменные хранятся в памяти?

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

Какой объем памяти выделяется для переменной?

Каковы последствия объявления переменной?

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

Что такое переменные в программе и как они хранятся в памяти?

Переменные — это имена, которые вы даете ячейкам памяти компьютера, которые используются для хранения значений в компьютерной программе. Создайте переменные с соответствующими именами. Сохраните свои значения в этих двух переменных. Извлекайте и используйте сохраненные значения переменных.

Выделяет ли память объявление переменной?

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

Зачем вам динамически выделять память?

Динамическое выделение памяти — это процесс выделения пространства памяти во время выполнения или во время выполнения. Причины и преимущества динамического выделения памяти: Когда мы заранее не знаем, сколько памяти потребуется для программы. . Если вы хотите более эффективно использовать пространство памяти.

Сколько существует типов выделения памяти?

Существует два типа выделения памяти. 1) Статическое выделение памяти - выделяется компилятором. Точный размер и тип памяти должны быть известны во время компиляции. 2) Динамическое выделение памяти — память выделяется во время выполнения.

Как мы можем динамически выделять память в C?

В C динамическая память выделяется из кучи с помощью некоторых стандартных библиотечных функций. Двумя ключевыми функциями динамической памяти являются malloc() и free(). Функция malloc() принимает единственный параметр — размер запрошенной области памяти в байтах. Он возвращает указатель на выделенную память.

Как Calloc распределяет память?

Функция calloc() выделяет память для массива из nmemb элементов размером байт каждый и возвращает указатель на выделенную память. Память обнуляется. Если nmemb или size равны 0, то calloc() возвращает либо NULL, либо уникальное значение указателя, которое позже может быть успешно передано в free().

Почему используется malloc?

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

Что такое динамическая память?

Куча памяти — это часть памяти, выделенная для JVM, которая совместно используется всеми выполняющимися потоками в приложении. Это часть JVM, в которой размещены все экземпляры классов и. Он создается в процессе запуска JVM. Он не обязательно должен быть непрерывным, а его размер может быть статическим или динамическим.

Какие существуют 5 типов переменных?

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

Какие четыре элемента информации вы можете собрать о переменной?

Какие четыре элемента информации вы можете собрать о переменной? Выберите ответ: тип данных, имя, оператор sizeof и оператор амперсанда.

Что такое переменная, поясните на примере?

Переменная — это величина, которую можно изменить в соответствии с математической задачей. Общие буквы, которые используются во многих алгебраических выражениях и уравнениях, это x, y, z. Другими словами, переменная — это символ числа, значение которого неизвестно. Например, x + 5 = 10. Здесь «x» — это переменная.

Как вы объявляете переменные?

Чтобы объявить (создать) переменную, вы должны указать тип, оставить хотя бы один пробел, затем имя переменной и закончить строку точкой с запятой ( ; ). Java использует ключевое слово int для целого числа, double для числа с плавающей запятой (число двойной точности) и boolean для логического значения (true или false).

Как правильно объявить указатель?

Синтаксис объявления указателя заключается в размещении * перед именем. Указатель также связан с типом (например, int и double).

Что такое стек и куча?

Стек — это линейная структура данных, а куча — иерархическая структура данных. Память стека никогда не будет фрагментирована, тогда как память кучи может стать фрагментированной, поскольку блоки памяти сначала выделяются, а затем освобождаются. Stack имеет доступ только к локальным переменным, тогда как Heap позволяет вам обращаться к переменным глобально.

Что такое динамическая переменная?

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

Как распределяется память в куче?

Куча — это общий термин, используемый для любой памяти, которая выделяется динамически и случайным образом. то есть вышел из строя. Память обычно выделяется ОС, а приложение вызывает функции API для этого выделения.

Как распределяются локальные переменные?

<р>2. Распределение — это создание хранилища памяти для локальной переменной. Компьютер выделяет пространство во время выполнения, уменьшая значение SP. В этом первом примере программа выделяет локальную переменную, помещая регистр в стек.

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

Общее расположение памяти

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

стек: хранит локальные переменные
куча: динамическая память, которую программист может выделить
данные: хранит глобальные переменные, разделенные на инициализированные и неинициализированные
text : хранит исполняемый код

Чтобы точно определить каждую ячейку памяти в памяти программы, мы присваиваем каждому байту памяти «адрес». Адреса идут от 0 до максимально возможного адреса, в зависимости от машины. Как показано на рисунке ниже, сегменты text , data и heap имеют низкие адреса, а память стека имеет более высокие адреса.

Разметка памяти программы на C++

По соглашению мы выражаем эти адреса в числах с основанием 16. Например, наименьший возможный адрес — 0x00000000 (где 0x означает основание 16), а самый большой возможный адрес может быть 0xFFFFFFFF .

Стек

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

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

Поскольку стековая память функции освобождается после возврата из функции, нет гарантии, что значение, хранящееся в этой области, останется прежним. Распространенной ошибкой является возврат указателя на переменную стека во вспомогательной функции. После того, как вызывающий объект получит этот указатель, недопустимая память стека может быть перезаписана в любое время. Следующие рисунки демонстрируют один пример такого сценария. Предположим, что существует класс Cube с методами getVolume и getSurfaceArea, а также с закрытой переменной width.

<р>3. Выделите указатель c для main и сохраните возвращенное значение. Обратите внимание, что стековая память CreateCube перезаписывается

<р>4. Выделите память стека для getVolume и вычислите объем, используя ширину c . Поскольку ширина c повреждена, громкость также неверна

<р>6. Выделите память стека для getSurfaceArea и вычислите площадь поверхности, используя ширину c . Как и в случае с getVolume, вычисленная площадь поверхности будет неверной

<р>7. Освободить память getSurfaceArea . Выделите v для main для хранения возвращаемого значения getSurfaceArea

В этих примерах представлена упрощенная версия стековой памяти. На самом деле стек функции хранит больше, чем просто локальные переменные. Вы можете узнать больше о том, что именно находится в стеке, пройдя курс компьютерной архитектуры. Кроме того, приведенный выше пример может вызвать ошибку сегментации, когда мы вызываем c->getVolume() или c->getSurfaceArea(). Это связано с тем, что если значение c неверно, машина не сможет найти функцию getVolume, связанную с c. Если это произойдет, эта программа завершится сбоем, а не выдаст неверные значения.

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

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

<р>1. Выделите целое число со значением по умолчанию 0 в куче, выделите p в стеке main для хранения адреса целого числа

<р>2. Выделите куб с шириной по умолчанию 20 в куче, выделите c1 в стеке main для хранения адреса куба

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

Это временное запоминающее устройство. Когда вычислительная задача будет завершена, память переменной будет автоматически стерта. Раздел стека в основном содержит методы, локальные переменные и ссылочные переменные.

В этом уроке вы узнаете,

Что такое куча?

Куча — это память, используемая языками программирования для хранения глобальных переменных. По умолчанию все глобальные переменные хранятся в куче памяти. Он поддерживает динамическое выделение памяти.

Куча не управляется автоматически для вас и не так жестко управляется процессором. Это больше похоже на свободно плавающую область памяти.

КЛЮЧЕВОЕ ОТЛИЧИЕ

Стек – это линейная структура данных, а куча – иерархическая структура данных.
Память стека никогда не будет фрагментирована, в то время как память кучи может стать фрагментированной, поскольку блоки памяти сначала выделяются, а затем освобождаются.
Stack имеет доступ только к локальным переменным, тогда как Heap позволяет вам обращаться к переменным глобально.
Размер переменных стека нельзя изменить, тогда как размер переменных кучи можно изменить.
Память стека выделяется в непрерывном блоке, тогда как память кучи выделяется в любом случайном порядке.
В стеке не требуется освобождать переменные, в то время как в куче требуется освобождение памяти.
Выделение и освобождение стека выполняются инструкциями компилятора, тогда как выделение и освобождение кучи выполняется программистом.

Ключевые различия между стеком и кучей

< td >Распределение и освобождение td>

Параметр	Стек	Куча
Тип структур данных	Стек — это линейная структура данных.	Куча — это иерархическая структура данных.
Скорость доступа< /td>	Высокоскоростной доступ	Медленнее по сравнению со стеком
Управление пространством	Пространство эффективно управляется ОС, поэтому память никогда не будет фрагментирована.	Пространство кучи используется не так эффективно. Память может стать фрагментированной, так как блоки памяти сначала выделяются, а затем освобождаются.
Доступ	Только локальные переменные	Это позволяет вам глобальный доступ к переменным.
Ограничение размера пространства	Ограничение размера стека в зависимости от ОС.	Не имеет конкретного ограничения от размера памяти.
Изменить размер	Размер переменных не может быть изменен	Размер переменных может быть изменен.
Распределение памяти	Память выделяется в непрерывном блоке.	Память выделяется в любом случайном порядке.
Автоматически выполняется инструкциями компилятора.	Это выполняется программистом вручную.
Освобождение	Не требует освобождения переменных.	Необходимо явное освобождение.
Стоимость	Меньше	Больше
Реализация	Стек может быть реализован тремя способами простой массив bas ed, с использованием динамической памяти и на основе связанного списка.	Куча может быть реализована с использованием массива и деревьев.
Основная проблема	Нехватка памяти	Фрагментация памяти
Локальность ссылки	Инструкции автоматического времени компиляции.	Адекватный< /td>
Гибкость	Фиксированный размер	Возможно изменение размера
Время доступа< /td>	Быстрее	Медленнее

Преимущества использования стека

Вот плюсы/преимущества использования стека:

Помогает управлять данными методом «последним пришел – первым обслужен» (LIFO), что невозможно при использовании связанных списков и массивов.
При вызове функции локальные переменные сохраняются в стеке, который автоматически уничтожается после возврата.
Стек используется, когда переменная не используется вне этой функции.
Он позволяет управлять выделением и освобождением памяти.
Стек автоматически очищает объект.
Не легко повредить
Размер переменных нельзя изменить.

Преимущества использования кучи

Куча помогает найти наибольшее и минимальное число
Сборка мусора выполняется в памяти кучи, чтобы освободить память, используемую объектом.
Метод кучи также используется в приоритетной очереди.
Он позволяет получить глобальный доступ к переменным.
У кучи нет ограничений на размер памяти.

Недостатки использования стека

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

Недостатки использования кучи

Он может предоставить максимальный объем памяти, который может предоставить ОС.
Для вычислений требуется больше времени.
Управление памятью в динамической памяти более сложно, поскольку она используется глобально.
Выполнение занимает слишком много времени по сравнению со стеком.

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

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

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

Локальные переменные — это структура программирования, которую все используют, но никто не задумывается. О них немного думаешь, когда впервые осваиваешь синтаксис. Но через несколько недель переменные становятся настолько автоматическими, что вы вскоре забываете думать о том, как они работают. Эта ситуация является заслугой современных языков программирования — большинство переменных времени появляются автоматически, когда они вам нужны, и они автоматически исчезают, когда вы закончите. Для базового программирования это прекрасная ситуация.Однако для продвинутого программирования будет полезно иметь представление о том, как работают переменные.

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

Самые распространенные переменные, которые вы используете, — это локальные переменные внутри функций, такие как переменные num и result в следующей функции. Все локальные переменные и параметры, вместе взятые, называются его локальным хранилищем или просто его «локальными».

Переменные называются «локальными», чтобы понять, что их время жизни привязано к функции, в которой они объявлены. Всякий раз, когда функция запускается, ее локальные переменные выделяются. Когда функция завершается, ее локальные ресурсы освобождаются. Для приведенного выше примера это означает, что при вызове функции Square() локальное хранилище выделяется для num и result . Утверждения типа result = num * num ; в функции использовать локальное хранилище. Когда функция, наконец, завершает работу, ее локальное хранилище освобождается.

Вот более подробная версия правил локального хранения:

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

Наконец, когда функция завершает работу и завершается, ее локальные ресурсы освобождаются. Имеет ли это смысл? Предположим, что местные жители каким-то образом продолжали существовать — как код вообще мог ссылаться на них? Такие имена, как num и result, в любом случае имеют смысл только внутри тела Square(). Как только поток управления покидает это тело функции, больше нет способа обратиться к локальным переменным, даже если они были выделены. То, что локальные значения доступны («ограничены») только в пределах их собственной функции, известно как лексическая область видимости. Сейчас почти все языки делают это так.

Вот простой пример срока службы локального хранилища.

Сохранение.
Ошибка сервера
Отправить повторно

Вот более крупный пример, показывающий, как простое правило «локальные ресурсы выделяются, когда их функция начинает выполняться, и освобождаются, когда она завершается» может привести к более сложному поведению. Вам потребуется твердое понимание того, как работает локальное распределение, чтобы понять материал последующих модулей. На следующих слайдах показана последовательность выделений и освобождений, возникающих в результате двойного вызова функцией X() функции Y().

Сохранение.
Ошибка сервера
Отправить повторно

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

5. 5.1.2. Локальные параметры¶

Локальные переменные тесно связаны со своей функцией — они используются только там и больше нигде. Только код X() может ссылаться на его a и b . Только код Y() может ссылаться на его p и q . Эта независимость от локального хранилища является основной причиной как его преимуществ, так и недостатков.

5. 5.1.3. Преимущества местных жителей¶

Локальные значения отлично подходят для 90 % потребностей программы в памяти:

Удобно. Локальные значения удовлетворяют удобную потребность — функциям часто требуется некоторая временная память, которая существует только во время вычисления функции. Локальные переменные удобно предоставляют такую временную, независимую память.

Эффективно. По сравнению с другими методами использования памяти локальные переменные более эффективны. Выделение и освобождение их занимает мало времени (быстро), и они экономят место в том, как они используют и утилизируют память

Локальные копии. Локальные параметры — это в основном локальные копии информации от вызывающей стороны. Это также известно как передача по значению. Параметры — это локальные переменные, которые инициализируются операцией присваивания (=) от вызывающего объекта.Вызывающий объект не «делится» значением параметра с вызываемым в смысле указателя — вызываемый объект получает свою собственную копию. Это имеет то преимущество, что вызываемый объект может изменить свою локальную копию, не затрагивая вызывающего. (Например, с параметром p в приведенном выше примере.) Эта независимость хороша, поскольку она разделяет работу вызывающей и вызываемой функций, что соответствует правилам хорошей разработки программного обеспечения — отдельные компоненты должны быть как можно более независимыми.

5. 5.1.4. Недостатки местных жителей¶

Местные жители имеют два недостатка:

Короткий срок службы. График их распределения и освобождения («время жизни») очень строгий. Иногда программе требуется память, которая продолжает выделяться даже после того, как функция, которая первоначально выделила ее, завершилась. Локальные переменные не будут работать, поскольку они автоматически освобождаются при выходе из функции-владельца. Эта проблема будет решена в следующем разделе, посвященном динамической памяти.

Ограниченное общение. Поскольку локальные переменные являются копиями параметров вызывающей стороны, они не обеспечивают средства связи между вызываемой стороной и вызывающей стороной. Это обратная сторона преимущества «независимости» — не всегда преимущество. Также иногда делать копии значения нежелательно по другим причинам. Мы увидим решение этой проблемы в следующем модуле.

5. 5.1.5. Синонимы для слова «местный»¶

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

5. 5.1.6. Сводка по локальной памяти¶

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

5. 5.1.7. Как работает стек вызовов функций?¶

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

Чтобы вызвать функцию, такую как foo(6, x+1):

Оцените фактические выражения параметров, такие как x+1 , в контексте вызывающего объекта.

Выделите память для локальных переменных foo(), поместив подходящий «локальный блок» памяти в стек вызовов во время выполнения, предназначенный для этой цели. Для параметров, но не для локальных переменных, сохраните значения из шага (1) в соответствующий слот в локальном блоке foo().

Сохранить текущий адрес выполнения вызывающего объекта (его «обратный адрес») и переключить выполнение на foo() .

foo() выполняется со своим локальным блоком, удобно доступным в конце стека вызовов.

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

Для особо любопытных вот другие примечания о процессе вызова функции:

Вот почему бесконечная рекурсия приводит к «Ошибке переполнения стека» — код продолжает вызывать и вызывать, что приводит к шагам (1) (2) (3), (1) (2) (3), но ни к одному шагу (4). В конце концов стек вызовов буквально исчерпывает память.

Вот почему локальные переменные имеют определенные начальные значения в зависимости от их типа. Шаг (2) просто проталкивает весь локальный блок за одну операцию. Каждый локальный объект получает свою собственную область памяти, но эта память будет содержать все, что осталось там от последнего арендатора. Эти значения будут удалены, и всем местным жителям будет присвоено начальное значение по умолчанию.

«Локальный блок» также известен как запись активации функции или кадр стека. Весь блок может быть помещен в стек (шаг 2) за одну операцию ЦП — это очень быстрая операция. Почему это можно сделать за одну операцию процессора? Поскольку отправка записи активации является настолько фундаментальной операцией для любого языка программирования, что разработчики ЦП обеспечивают ее прямую поддержку.

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

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

Читайте также: