Можно ли получить доступ к памяти локальной переменной вне ее области?

то, что вы здесь делаете, это просто чтение и запись в память, что раньше адрес a. Теперь, когда вы находитесь за пределами foo, это всего лишь указатель на некоторую случайную область памяти. Так уж случилось, что в вашем примере эта область памяти действительно существует, и ничто другое не использует ее в данный момент. Вы ничего не нарушаете, продолжая использовать его, и ничто другое еще не перезаписало его. Таким образом,5 до сих пор нет. В реальной программе эта память будет повторно используется почти сразу, и вы бы сломать что-то, делая это (хотя симптомы не могут появиться до гораздо позже!)

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

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

короче говоря: это обычно не работает, но иногда случайно.

потому что место для хранения еще не было растоптано. Не рассчитывайте на такое поведение.

небольшое дополнение ко всем ответам:

Если вы делаете что-то вроде этого:

#include<stdio.h>
#include <stdlib.h>
int * foo(){
    int a = 5;
    return &a;
}
void boo(){
    int a = 7;

}
int main(){
    int * p = foo();
    boo();
    printf("%d\n",*p);
}

выход, вероятно, будет: 7

это потому, что после возвращения из foo() стек освобождается, а затем повторно используется boo(). Если вы деассемблируете исполняемый файл, вы увидите его ясно.

В C++, вы can доступ к любому адресу, но это не значит, что вы должны. Адрес, к которому вы обращаетесь, больше не действителен. Это работает потому что ничто другое не скремблировало память после того, как Фу вернулся, но он мог разбиться при многих обстоятельствах. Попробуйте проанализировать вашу программу с помощью отчет, или даже просто компиляция оптимизирована, и смотрите...

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

unsigned int q = 123456;

*(double*)(q) = 1.2;

здесь я просто рассматриваю 123456 как адрес двойника и пишу ему. Любое количество вещей может произойти:

1. q может на самом деле действительно быть действительным адресом двойника, например double p; q = &p;.
2. q может где-то точки внутри выделенной памяти и я просто перезаписать 8 байт там.
3. q точки вне выделенной памяти и диспетчер памяти операционной системы посылает сигнал ошибки сегментации в мою программу, в результате чего среда выполнения завершает его.
4. вы выигрываете в лотерею.

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

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

вы скомпилировали свою программу с включенным оптимизатором ?

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

но я Агре с маркой B, что результирующее поведение не определено.

ваша проблема не имеет ничего общего с scope. В коде, который вы показываете, функция main не видит имена в функции foo, Так что вы не можете открыть a в foo непосредственно с этой имя за пределами foo.

проблема, с которой вы столкнулись, заключается в том, почему программа не сигнализирует об ошибке при ссылке на незаконную память. Это связано с тем, что стандарты C++ не определяют очень четкую границу между незаконной памятью и законной памятью. Ссылающийся что-то в выскочил стек иногда вызывает ошибку, а иногда и нет. Это зависит от. Не рассчитывайте на такое поведение. Предположим, что это всегда приведет к ошибке при программировании, но предположим, что он никогда не будет сигнализировать об ошибке при отладке.

вы просто возвращаете адрес памяти, это разрешено, но, вероятно, ошибка.

да если вы попытаетесь разыменовать этот адрес памяти, у вас будет неопределенное поведение.

int * ref () {

 int tmp = 100;
 return &tmp;
}

int main () {

 int * a = ref();
 //Up until this point there is defined results
 //You can even print the address returned
 // but yes probably a bug

 cout << *a << endl;//Undefined results
}

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

это поведение не определено, как отметил Алекс-на самом деле, большинство компиляторов будут предупреждать об этом, потому что это простой способ получить сбои.

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

int *a()
{
   int x = 5;
   return &x;
}

void b( int *c )
{
   int y = 29;
   *c = 123;
   cout << "y=" << y << endl;
}

int main()
{
   b( a() );
   return 0;
}

это выводит "y=123", но ваши результаты могут отличаться (действительно!). Ваш указатель сбивает другие, несвязанные локальные переменные.

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

вы фактически вызвали неопределенное поведение.

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

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

в типичных реализациях компилятора вы можете думать о коде как " распечатать значение блока памяти с адресом, который раньше занято a". Кроме того, если вы добавляете новый вызов функции к функции, которая содержит локальный int Это хороший шанс, что значение a (или адрес памяти, что a используется для указания на) изменения. Это происходит потому, что стек будет перезаписан новым фреймом, содержащим другие данные.

, это неопределено поведение, и вы не должны полагаться на него работать!

обратите внимание на все предупреждения . Не только решать ошибки.
GCC показывает это предупреждение

внимание: адрес локальной переменной' a ' возвращается

это сила C++. Вы должны заботиться о памяти. С помощью -Werror флаг, это предупреждение становится ошибкой, и теперь вы должны отладить его.

может, потому что a - Это переменная, временно выделенная на время существования ее области видимости (

вещи с правильной (?) выход консоли может резко измениться, если вы используете ::printf, но не cout. Вы можете поиграть с отладчиком в приведенном ниже коде (проверено на x86, 32-бит, MSVisual Studio):

char* foo() 
{
  char buf[10];
  ::strcpy(buf, "TEST”);
  return buf;
}

int main() 
{
  char* s = foo();    //place breakpoint & check 's' varialbe here
  ::printf("%s\n", s); 
}

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

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

позвольте мне возьмем реальный пример:

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

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