call stack

call stack (tsz. call stacks)

1. (informatika) A call stack (hívási verem) egy olyan memória-terület, amelyet a program függvényhívások kezelésére használ. Ez egy LIFO (Last In, First Out – utoljára be, elsőként ki) struktúra, amely minden függvényhívásnál egy új stack frame-et hoz létre. A függvények visszatérésekor a megfelelő stack frame törlődik.

A Call Stack az alábbi módon működik:

1. Amikor egy függvény meghívódik:
   • Új stack frame jön létre a hívási veremben.
   • Ebben a frame-ben tárolódnak:
     • A függvény paraméterei.
     • A függvény lokális változói.
     • A visszatérési cím, hogy a függvény vége után a program tudja, hova térjen vissza.
2. Amikor a függvény befejeződik:
   • A megfelelő stack frame törlődik a veremből.
   • A vezérlés visszatér az előző függvénybe (a meghívó helyre).

#include <iostream>
using namespace std;

void fuggvenyB() {
    cout << "Függvény B meghívva" << endl;
}

void fuggvenyA() {
    cout << "Függvény A meghívva" << endl;
    fuggvenyB(); // Meghívja fuggvenyB()-t
}

int main() {
    cout << "main() függvény kezdődik" << endl;
    fuggvenyA(); // Meghívja fuggvenyA()-t
    cout << "main() függvény véget ért" << endl;
    return 0;
}

1. main() meghívása
   • main stack frame létrejön.
2. fuggvenyA() meghívása
   • fuggvenyA stack frame kerül a main fölé.
3. fuggvenyB() meghívása
   • fuggvenyB stack frame kerül a fuggvenyA fölé.
4. fuggvenyB() befejeződik
   • fuggvenyB stack frame törlődik.
5. fuggvenyA() befejeződik
   • fuggvenyA stack frame törlődik.
6. main() befejeződik
   • main stack frame törlődik, és a program véget ér.

Kimenet:

main() függvény kezdődik
Függvény A meghívva
Függvény B meghívva
main() függvény véget ért

Mivel minden függvényhívás egy új stack frame-et hoz létre, a rekurzió nagy mélység esetén stack overflow-t okozhat.

void szamolas(int n) {
    if (n == 0) return; // Kilépési feltétel
    cout << "n: " << n << endl;
    szamolas(n - 1);
}

int main() {
    szamolas(5);
    return 0;
}

Call Stack állapota 5 → 4 → 3 → 2 → 1 → 0 - szamolas(5) → szamolas(4) → szamolas(3) → szamolas(2) → szamolas(1) → szamolas(0) - Ekkor a stack visszafelé törlődik.

✅ Nincs stack overflow, mert van kilépési feltétel (n == 0).

A végtelen vagy túl mély rekurzió stack overflow-hoz vezet, mert minden rekurzív hívás új stack frame-et hoz létre, és végül elfogy a memória.

void vegtelenRekurzio() {
    vegtelenRekurzio(); // Végtelen hívás
}

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

🔴 Hiba: A vegtelenRekurzio() folyamatosan hívja önmagát, míg a Call Stack teljesen megtelik, és a program összeomlik.

Ha egy program mély rekurziót használ, növelhetjük a stack méretét:

1. Project Settings → Linker → System → Stack Reserve Size
   

2. Vagy parancssorból:

   link /STACK:20000000 program.exe

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

ulimit -s 100000

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

• Ha nagy méretű tömböket kell tárolni.
• Ha az adatoknak túl kell élniük egy függvényhívást.
• Ha a program sok memóriahasználatot igényel, és a stack túl kicsi.

🔹 A Call Stack minden függvényhívásnál új stack frame-et hoz létre.
🔹 A stack gyors, de korlátozott méretű.
🔹 Túl sok rekurzió vagy nagy lokális változók stack overflow-hoz vezethetnek.
🔹 Megoldások stack overflow elkerülésére: - Használj kilépési feltételt rekurzió esetén! - Használj iterációt rekurzió helyett! - Nagy adatokat tárolj a heap memóriában!

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