stack memory

stack memory (tsz. stack memories)

1. (informatika) A stack memória egy speciális memóriaterület, amelyet a program futása során használ a függvényhívásokhoz és lokális változók tárolásához. A C++ programokban a stack gyors és automatikus memória-kezelést biztosít, de korlátozott méretű, és ha túl sok memóriát próbálunk lefoglalni, stack overflow (verem túlcsordulás) hiba léphet fel.

A programok memóriahasználata általában négy fő területre oszlik:

1. Stack (verem) memória – Lokális változók és függvényhívások tárolására szolgál. Automatikusan kezelt.
2. Heap (kupac) memória – Dinamikusan foglalt memória (new, delete használatával).
3. Data (adat szegmens) – Globális és statikus változók tárolására.
4. Code (kódszegmens) – Maga a programkód.

A stack memória egy LIFO (Last In, First Out – utoljára be, elsőként ki) elven működő adattároló struktúra.

A stack memória működését az alábbi példa szemlélteti:

#include <iostream>
using namespace std;

void fuggveny1(int x) {
    int y = x * 2; // Lokális változó a stack memóriában
    cout << "y értéke: " << y << endl;
}

int main() {
    int a = 5; // Lokális változó
    fuggveny1(a); // Új stack frame létrejön
    return 0;
}

1. A main() függvény meghívása – a a változó a stackbe kerül.
2. A fuggveny1(a) hívása – új stack frame jön létre a x és y változóknak.
3. A fuggveny1 befejeződik, és a x és y változók törlődnek a stackből.
4. A main() befejeződik, és az a változó is törlődik.

A stack memória gyors, mivel a változók automatikusan felkerülnek és törlődnek, amikor a függvény visszatér.

Minden függvényhívás egy új stack frame-et hoz létre, amely tartalmazza: - A függvény paramétereit. - A lokális változókat. - A visszatérési címet, hogy a függvény befejezése után a program tudja, hova kell visszatérnie.

#include <iostream>
using namespace std;

void f1(int n) {
    int x = n * 2; // Lokális változó
    cout << "x: " << x << endl;
}

void f2() {
    int y = 100; // Másik stack frame-ben tárolt változó
    f1(y);
}

int main() {
    f2(); // Stackben f2() → f1() kerül
    return 0;
}

🔹 Stack memória állapota:

| f1 stack frame (n, x) | <-- Legújabb
| f2 stack frame (y)    |
| main stack frame      | <-- Legrégebbi

Minden függvény befejezése után a megfelelő stack frame törlődik.

A stack memória véges méretű. Ha egy program túl sok memóriát használ a stack-ben, stack overflow (verem túlcsordulás) léphet fel.

void vegtelenRekurzio() {
    vegtelenRekurzio(); // Nincs kilépési feltétel!
}

int main() {
    vegtelenRekurzio(); // Stack overflow
    return 0;
}

🔴 Hiba: A függvény folyamatosan hívja önmagát, míg a stack memória elfogy.

✅ Megoldás: Adjunk hozzá egy kilépési feltételt:

void helyesRekurzio(int n) {
    if (n == 0) return;
    helyesRekurzio(n - 1);
}

void nagyTomb() {
    int tomb; // Túl nagy tömb a stack-ben
}

int main() {
    nagyTomb(); // Stack overflow
    return 0;
}

🔴 Hiba: A túl nagy tömb a stack memória túllépéséhez vezet.

✅ Megoldás: Használjunk heap memóriát:

void nagyTomb() {
    int* tomb = new int; // Heap használata
    delete tomb;
}

• Ha nagy méretű tömböket kell tárolni.
• Ha az adatokat meg kell osztani több függvény között.
• Ha az adatokat a program futása közben kell létrehozni vagy törölni.

A stack mérete módosítható a Visual Studio linker beállításaiban: 1. Project Properties → Linker → System → Stack Reserve Size.

Vagy parancssorból:

link /STACK:20000000 program.exe

Ez 20 MB-ra növeli a stack méretét.

A stack mérete módosítható a következő paranccsal:

ulimit -s 100000

Ez a stack méretét 100 MB-ra állítja.

🔹 A stack memória gyors és automatikusan kezelt.
🔹 Minden függvényhívás új stack frame-et hoz létre.
🔹 Túl sok rekurzió vagy nagy tömb stack overflow-hoz vezethet.
🔹 Heap memória használata ajánlott nagy adatoknál.
🔹 A stack méretét lehet növelni operációs rendszer szinten.

• stack memory - Szótár.net (en-hu)
• stack memory - Sztaki (en-hu)
• stack memory - Merriam–Webster
• stack memory - Cambridge
• stack memory - WordNet
• stack memory - Яндекс (en-ru)
• stack memory - Google (en-hu)
• stack memory - Wikidata
• stack memory - Wikipédia (angol)