Где переменные в C++ сохранены?

Переменные хранятся:

• на стеке, если они auto- функциональные локальные переменные matic
• на "куче", если они выделяются с new или malloc, и т.д. (детали то, что это означает говорить "переменную, хранится в "куче"" в комментариях),
• в области данных для каждого процесса, если они глобальны или static

Это - все в RAM, конечно. Кэширование очевидно для процессов пространства пользователя, хотя оно может выполнение влияния visibily.

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

Для C++ в целом, надлежащий ответ "везде, где Ваш компилятор решает поместить их". Вы не должны делать предположения иначе, если Вы так или иначе не направляете свой компилятор иначе. Некоторые переменные могут быть сохранены полностью в регистрах, и некоторые могли бы быть полностью оптимизированы далеко и заменены литералом где-нибудь. С некоторыми компиляторами на некоторых платформах константы могли бы на самом деле закончиться в ROM.

Часть Вашего вопроса о "кэше процессора" немного перепутана. Существуют некоторые инструменты для направления, как процессор обрабатывает свой кэш, но в целом который является бизнесом процессора и должен быть невидим для Вас. Можно думать о кэше как окне о ЦП в RAM. В значительной степени любой доступ к памяти проходит кэш.

На другом конце уравнения неиспользованная RAM иногда будет выгружаться к диску на большинстве Ose. Так его возможное (но вряд ли), что в несколько моментов Ваши переменные на самом деле хранятся на диске.:-)

C++ не знает о кэше Вашего процессора.

Когда Вы запустите программу, записанную в C++ или любом другом языке, Ваш ЦП сохранит копию "популярных" блоков RAM в кэше. Это сделано на аппаратном уровне.

Не думайте о кэше ЦП как "другой" или "больше" память... это - просто механизм для хранения некоторых блоков RAM рядом.

Переменные в C++ хранятся или на стеке или на "куче".

стек:

int x;

"куча":

int *p = new int;

Однако оба - структуры, созданные в RAM.

Если Ваше Использование оперативной памяти высоко, хотя окна могут выгрузить это к диску.

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

Я думаю, что Вы перепутываете два понятия. Один, как язык C++ хранит переменные в памяти. Два, как компьютерная и операционная система управляет той памятью.

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

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

Переменные могут быть сохранены во многих различных местах, иногда больше чем в одном месте. Большинство переменных помещается в RAM, когда программа загружается; иногда переменные, которые объявляются const вместо этого помещаются в ROM. Каждый раз, когда к переменной получают доступ, если это не будет в кэше процессора, то неудачное обращение в кэш закончится, и процессор остановится, в то время как переменная копируется с RAM/ROM в кэш.

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

Переменные обычно хранятся в RAM. Это находится любой на "куче" (например, все глобальные переменные будут обычно идти туда), или на стеке (все переменные, объявленные в рамках метода/функции обычно, идут туда). Стек и "куча" являются оба RAM, просто различные местоположения. Указатели имеют различные правила. Указатель на что-то (блок памяти, объект, и т.д.) сам обычно следует правилам вышеупомянутых (указатель, объявленный в функции, хранится на стеке), но данные, на которые это указывает (сам блок памяти или объект Вы создали с новым) хранятся на "куче". Можно создать указатели, указывающие на стек (например, "интервал = 10; интервал * b = &a"; b указывает на a и сохраненного на стеке), но выделение памяти с помощью malloc или новые количества к памяти "кучи".

То, что входит в кэш ЦП, находится вне контроля компиляторами, ЦП решает себя, что кэшироваться и как к долго для кэширования его (в зависимости от факторов как "Эти данные недавно использовался?" или "Нужно ожидать, что данные используются довольно скоро снова?" и конечно размер кэша имеет большое влияние, как долго центральные процессоры сохранят данные там - чем больше кэша они имеют, тем больше данных, они могут кэшировать и дольше они могут сохранить данные там прежде, чем освободить пространство кэша для новых данных).

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

в зависимости от того, как они объявляются, они будут или сохранены в "куче" или "стеке"

"Куча" является динамической структурой данных, которую может использовать приложение.

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