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

то, что вы делаете здесь, это просто чтение и запись в память, что раньше адрес 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 доступ к любому адресу, но это не значит, что вы должны. Адрес вы обращаетесь уже не действует. Это работает потому что ничего другого яичница памяти после Foo вернулся, но она может рухнуть при многих обстоятельствах. Попробуйте проанализировать свою программу с помощью отчет, или даже просто компиляция оптимизирована, и смотрите...

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

unsigned int q = 123456;

*(double*)(q) = 1.2;

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

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

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

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

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

но я согласны с Марком Б, что в результате приведет к неопределенному поведению.

ваша проблема не имеет ничего общего с область. В коде, который вы показываете, функция 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 когда-то был. Эта разница очень похожа на разницу между сбоем и не сбоем.

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

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

warning: адрес локальной переменной ' a ' returned

это сила 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++ не останавливает вас от такого "грязного" доступа (может предупредить вас, если вам все равно). Вы можете безопасно использовать (обновлять) любое место памяти, которое находится в сегменте данных вашего экземпляра программы (процесса), если вы не защитите адрес каким-либо образом.