C++ Academy · Lekcja

Alokacja na stosie

Poznaj działanie pamięci automatycznej

Alokacja na stosie to bezpłatna lekcja C++ Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C++ Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C++ Academy zawiera 4 lekcji w sumie.

Pamięć automatyczna

Zmienne lokalne są przechowywane w pamięci automatycznej, powszechnie nazywanej stosem. Są tworzone przy wejściu wykonania do ich zakresu i niszczone przy jego opuszczeniu.

#include <iostream>

int main() {
    int x = 42;          // on the stack
    double pi = 3.14;    // on the stack
    std::cout << x << " " << pi << "\n";
}

Stos rośnie i maleje

Każde wywołanie funkcji umieszcza na stosie ramkę stosu zawierającą jej zmienne lokalne. Po powrocie z funkcji ramka jest zdejmowana, a zmienne lokalne znikają — nie jest potrzebne ręczne sprzątanie.

#include <iostream>

void greet() {
    int local = 7;          // pushed on call
    std::cout << local << "\n";
}                            // popped on return

int main() { greet(); }

Kolejność LIFO

Stos działa zgodnie z zasadą Last In, First Out. Ostatnia utworzona zmienna lokalna jest niszczona jako pierwsza po zakończeniu zakresu.

#include <iostream>

int main() {
    int a = 1;
    {
        int b = 2;   // created after a
        std::cout << b << "\n";
    }                // b destroyed first
    std::cout << a << "\n";
}

Szybko i tanio

Alokowanie na stosie jest niezwykle szybkie: polega jedynie na przesunięciu wskaźnika stosu. Nie trzeba wyszukiwać wolnej pamięci ani prowadzić księgowości wymaganej przez stertę.

Zakres określa czas życia

Obiekt na stosie istnieje tylko wewnątrz bloku, w którym został zadeklarowany. Zagnieżdżone bloki mają własne zakresy.

#include <iostream>

int main() {
    for (int i = 0; i < 3; ++i) {
        int square = i * i;   // recreated each iteration
        std::cout << square << "\n";
    }
}

Ograniczony rozmiar

Stos ma stały, ograniczony rozmiar (często kilka megabajtów). Alokowanie dużych tablic na stosie może spowodować awarię typu przepełnienie stosu.

// Risky: a large fixed array on the stack
int big[1000000];   // may overflow the stack

Zwracanie adresu ze stosu jest błędem

Nigdy nie należy zwracać wskaźnika ani referencji do zmiennej lokalnej. Po powrocie z funkcji zajmowana przez nią pamięć przestaje istnieć, a wskaźnik staje się wiszący.

int* bad() {
    int local = 5;
    return &local;   // BUG: local dies here
}

Przekazywanie dużych obiektów przez referencję

Kopiowanie dużych obiektów na stos jest nieefektywne. Przekazuj je przez const&, aby uniknąć kopiowania i ograniczyć zużycie stosu.

#include <string>

void print(const std::string& s) {  // no copy
    // use s
}

Obiekty stosu nie wymagają delete

Ponieważ kompilator automatycznie zarządza ich czasem życia, nigdy nie wolno wywoływać delete dla zmiennej na stosie.

#include <iostream>

int main() {
    int n = 10;
    // delete &n;   // ERROR: not heap-allocated
    std::cout << n << "\n";
}

Tablice na stosie

Tablice o stałym rozmiarze i znanej długości są przechowywane na stosie i automatycznie zwalniane po zakończeniu zakresu.

#include <iostream>

int main() {
    int values[3] = {10, 20, 30};
    for (int v : values) std::cout << v << "\n";
}

Kiedy preferować stos

Preferuj stos dla małych obiektów o krótkim czasie życia, których rozmiar jest znany w czasie kompilacji. Stos jest szybszy i automatycznie zwalnia pamięć — sięgaj po stertę tylko wtedy, gdy naprawdę jej potrzebujesz.

Szybki test

Sprawdź swoją wiedzę na temat alokacji na stosie.

Podsumowanie

Nauczyłeś się, że alokacja na stosie korzysta z automatycznego przechowywania powiązanego z zakresem: zmienne są tworzone przy wejściu do zakresu i niszczone przy wyjściu z niego, w kolejności LIFO. Jest szybka, automatycznie zwalnia pamięć i ma ograniczony rozmiar. Nigdy nie zwracaj adresów zmiennych lokalnych i nigdy nie używaj delete dla obiektów stosu.

Często zadawane pytania

Czy lekcja „Alokacja na stosie” jest bezpłatna?

Tak — pełny tekst „Alokacja na stosie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C++ Academy, przejdź na CoddyKit PRO. Kurs C++ Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Alokacja na stosie”?

Poznaj działanie pamięci automatycznej Ćwiczysz C++ Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C++ Academy?

Nie wymagamy żadnego doświadczenia. C++ Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Alokacja na stosie”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C++ Academy?

Tak. Każda lekcja C++ Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C++ Academy