Czy pamięć zmiennej lokalnej może być dostępna poza jej zakresem?

To, co tutaj robisz, to po prostu czytanie i zapisywanie do pamięci, która kiedyś była adresem a. Teraz, gdy jesteś poza foo, to tylko wskaźnik do jakiegoś przypadkowego obszaru pamięci. Tak się składa, że w twoim przykładzie ten obszar pamięci istnieje i nic innego go w tej chwili nie używa. Nie łamiesz niczego, kontynuując korzystanie z niego, i nic innego nie nadpisało go jeszcze. Dlatego 5 nadal tam jest. W prawdziwym programie Pamięć ta byłaby ponownie wykorzystywana niemal natychmiast i można złamać coś robiąc to (choć objawy mogą pojawić się dopiero znacznie później!)

Kiedy wrócisz z foo, powiesz systemowi, że nie używasz już tej pamięci i możesz ją przypisać do czegoś innego. Jeśli masz szczęście i nigdy nie zostanie przeniesiony, a system operacyjny nie przyłapie Cię na używaniu go ponownie, to ujdzie ci to na sucho. Są szanse, że skończysz pisząc o tym, co jeszcze kończy się z tym adresem.

Teraz, jeśli jesteś zastanawiam się, dlaczego kompilator nie narzeka, prawdopodobnie dlatego, że foo został wyeliminowany przez optymalizację. Zazwyczaj ostrzega Cię przed takimi rzeczami. C zakłada, że wiesz, co robisz, i technicznie nie naruszyłeś tu zakresu (nie ma odniesienia do samej a poza foo), tylko reguły dostępu do pamięci, które tylko wyzwalają Ostrzeżenie, a nie błąd.

W skrócie: to zwykle nie zadziała, ale czasami będzie przez przypadek.

Ponieważ przestrzeń magazynowa nie została jeszcze nadepnięta. Nie licz na takie zachowanie.

Mały dodatek do wszystkich odpowiedzi:

Jeśli zrobisz coś takiego:

#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);
}

Wyjście prawdopodobnie będzie: 7

Dzieje się tak dlatego, że po powrocie z foo() stos jest zwalniany, a następnie ponownie używany przez boo(). Jeśli zdemontujesz plik wykonywalny, zobaczysz go wyraźnie.

W C++, Możesz uzyskać dostęp do dowolnego adresu, ale to nie znaczy, że powinieneś. Adres, na który uzyskujesz dostęp, nie jest już ważny. To działa ponieważ nic innego nie zakłóciło pamięci po powrocie foo, ale może się rozbić w wielu okolicznościach. Spróbuj przeanalizować swój program za pomocą Valgrind , lub nawet po prostu skompilować go zoptymalizowanym i zobacz...

Nigdy nie wyrzucasz wyjątku C++ poprzez dostęp do nieprawidłowej pamięci. Podajesz tylko przykład ogólnej idei odwoływania się do arbitralnej lokalizacji pamięci. Mógłbym zrobić to samo tak:

unsigned int q = 123456;

*(double*)(q) = 1.2;

Tutaj po prostu traktuję 123456 jako adres sobowtóra i piszę do niego. Każda liczba rzeczy może się zdarzyć:

1. q może w rzeczywistości być poprawnym adresem podwójnego, np. double p; q = &p;.
2. q może wskazywać gdzieś wewnątrz pamięci i po prostu zastąp tam 8 bajtów.
3. q wskazuje poza przydzieloną pamięcią, a Menedżer pamięci systemu operacyjnego wysyła sygnał błędu segmentacji do mojego programu, powodując jego zakończenie.
4. wygrywasz na loterii.

Sposób, w jaki go skonfigurujesz, jest nieco bardziej rozsądny, że zwracany adres wskazuje na prawidłowy obszar pamięci, ponieważ prawdopodobnie będzie nieco dalej w dół stosu, ale nadal jest to Nieprawidłowa lokalizacja, do której nie można uzyskać dostępu w deterministyczna Moda.

Nikt nie będzie automatycznie sprawdzał poprawności semantycznej adresów pamięci w ten sposób podczas normalnego wykonywania programu. Jednak debuger pamięci, taki jak valgrind, z przyjemnością to zrobi, więc powinieneś uruchomić swój program i być świadkiem błędów.

Czy skompilowałeś swój program z włączonym optymalizatorem? Funkcja foo() jest dość prosta i mogła zostać wstawiona lub zastąpiona w kodzie wynikowym.

Ale Zgadzam się z Markiem B, że wynikowe zachowanie jest niezdefiniowane.

Twój problem nie ma nic wspólnego z zakresem . W wyświetlonym kodzie funkcja main nie widzi nazw w funkcji foo, więc nie możesz uzyskać dostępu a w foo bezpośrednio z TA Nazwa poza foo.

Problem, który masz, polega na tym, że program nie sygnalizuje błędu podczas odwoływania się do nielegalnej pamięci. Dzieje się tak dlatego, że standardy C++ nie określają bardzo wyraźnej granicy między pamięcią nielegalną a pamięcią legalną. Nawiązywanie do czegoś w stos czasami powoduje błąd, a czasami nie. To zależy. Nie licz na takie zachowanie. Załóżmy, że zawsze spowoduje to błąd podczas programowania, ale załóżmy, że nigdy nie będzie sygnalizować błędu podczas debugowania.

Po prostu zwracasz adres pamięci, jest to dozwolone, ale prawdopodobnie błąd.

Tak jeśli spróbujesz dereferować adres pamięci, będziesz miał nieokreślone zachowanie.

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
}

To klasyczne nieokreślone zachowanie , o którym mówiono tu nie dwa dni temu.przeszukaj trochę stronę. W skrócie, miałeś szczęście, ale wszystko mogło się zdarzyć, a Twój kod powoduje nieprawidłowy dostęp do pamięci.

To zachowanie jest niezdefiniowane, jak zauważył Alex-w rzeczywistości większość kompilatorów ostrzega przed tym, ponieważ jest to łatwy sposób na awarie.

Dla przykładu rodzaju upiornego zachowania, które prawdopodobnie uzyskasz , wypróbuj tę próbkę:

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;
}

To wypisuje "y=123" , ale Twoje wyniki mogą się różnić (naprawdę!). Twój wskaźnik zatyka inne, niepowiązane zmienne lokalne.

Zwróć uwagę na wszystkie ostrzeżenia . Nie tylko rozwiązuj błędy.
GCC pokazuje to Ostrzeżenie

Warning: zwracany adres zmiennej lokalnej 'a'

To jest potęga C++. Powinieneś dbać o pamięć. Z flagą -Werror to Ostrzeżenie staje się błędem i teraz musisz go debugować.

To działa, ponieważ stos nie został zmieniony (jeszcze) od kiedy a został tam umieszczony. Wywołaj kilka innych funkcji (które również wywołują inne funkcje) przed ponownym dostępem do a, a prawdopodobnie nie będziesz już taki szczęśliwy... ;-)

Powołałeś się na nieokreślone zachowanie.

Zwracanie adresu tymczasowego działa, ale gdy tymczasowe obiekty są niszczone na końcu funkcji, wyniki dostępu do nich będą niezdefiniowane.

Więc nie zmodyfikowałeś a, ale raczej Miejsce Pamięci, w którym kiedyś było a. Różnica ta jest bardzo podobna do różnicy między upaść i nie upaść.

W typowych implementacjach kompilatora można myśleć o kodzie jako "wydrukuj wartość bloku pamięci z adresem, który był kiedyś zajęty przez a". Ponadto, jeśli dodasz nowe wywołanie funkcji do funkcji, która konstruuje lokalny int, jest duża szansa, że wartość a (lub adres pamięci, na który wskazuje a) ulegnie zmianie. Dzieje się tak, ponieważ stos zostanie nadpisany nową ramką zawierającą inne dane.

Jednak jest to undefined zachowanie i nie powinieneś na nim polegać!

Może, ponieważ {[0] } jest zmienną przydzieloną tymczasowo na czas trwania jej zakresu (foo funkcja). Po powrocie z foo pamięć jest wolna i można ją nadpisać.

To, co robisz, jest opisane jako nieokreślone zachowanie . Wyniku nie da się przewidzieć.

Rzeczy z poprawnym (?) wyjście konsoli może się radykalnie zmienić, jeśli używasz metody:: printf, ale nie cout. Możesz pobawić się debuggerem w poniższym kodzie (testowanym na x86, 32-bit, 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); 
}

Po powrocie z funkcji, wszystkie identyfikatory są niszczone zamiast wartości przechowywanych w pamięci i nie możemy zlokalizować wartości bez posiadania identyfikatora.Ale ta lokalizacja nadal zawiera wartość zapisaną przez poprzednią funkcję.

Więc tutaj funkcja foo() zwraca adres a i {[1] } jest niszczona po zwróceniu jej adresu. I możesz uzyskać dostęp do zmodyfikowanej wartości poprzez ten zwrócony adres.

Let me take a real world przykład:

To "brudny" sposób używania adresów pamięci. Zwracając adres (wskaźnik) nie wiesz, czy należy on do lokalnego zakresu funkcji. To tylko adres. Teraz, gdy wywołałeś funkcję 'foo', ten adres (lokalizacja pamięci) 'a' został już przydzielony tam w (bezpiecznie, przynajmniej na razie) adresowalnej pamięci twojej aplikacji (procesu). Po zwróceniu funkcji " foo " adres "a" może być uznany za "brudny", ale jest tam, nie jest wyczyszczony, ani disturbed/modified by expressions in other part of program (in this specific case conajmniej). Kompilator C / C++ nie powstrzymuje cię przed takim "brudnym" dostępem(może cię jednak ostrzec, jeśli Ci zależy). Możesz bezpiecznie używać (aktualizować) dowolnej lokalizacji pamięci znajdującej się w segmencie danych instancji programu (procesu), chyba że w jakiś sposób zabezpieczysz adres.

Twój kod jest bardzo ryzykowny. Tworzysz zmienną lokalną (która jest uważana za zniszczoną po zakończeniu funkcji) i zwracasz adres pamięci tej zmiennej po jej destoyed.

Oznacza to, że adres pamięci może być poprawny lub nie, a Twój kod będzie podatny na ewentualne problemy z adresem pamięci (na przykład błąd segmentacji).

Oznacza to, że robisz bardzo złą rzecz, ponieważ przekazujesz adres pamięci do wskaźnika, który nie jest godny zaufania w wszystkie.

Rozważ ten przykład i przetestuj go:

int * foo()
{
   int *x = new int;
   *x = 5;
   return x;
}

int main()
{
    int* p = foo();
    std::cout << *p << "\n"; //better to put a new-line in the output, IMO
    *p = 8;
    std::cout << *p;
    delete p;
    return 0;
}

W przeciwieństwie do twojego przykładu, z tym przykładem jesteś:

• przydzielanie pamięci dla int do funkcji lokalnej
• ten adres pamięci jest nadal ważny również wtedy, gdy funkcja wygaśnie, (nie jest usuwana przez nikogo)
• adres pamięci jest zaufany (ten blok pamięci nie jest uważany za wolny, więc nie zostanie nadpisany, dopóki nie zostanie usunięty)
• adres pamięci powinien zostać usunięty, gdy nie używany. (zobacz Usuń na końcu programu)