call stack (tsz. call stacks)
A Call Stack az alábbi módon működik:
#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;
}
main()
meghívása
main
stack frame létrejön.fuggvenyA()
meghívása
fuggvenyA
stack frame kerül a main
fölé.fuggvenyB()
meghívása
fuggvenyB
stack frame kerül a fuggvenyA
fölé.fuggvenyB()
befejeződik
fuggvenyB
stack frame törlődik.fuggvenyA()
befejeződik
fuggvenyA
stack frame törlődik.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:
Project Settings → Linker → System → Stack Reserve Size
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.)
Tulajdonság | Call Stack (Hívási verem) | Heap memória |
---|---|---|
Sebesség | Nagyon gyors | Lassabb |
Foglalás módja | Automatikus (függvényhívásokkor) | Manuális (new és delete )
|
Méret | Korlátozott | Nagyobb |
Visszanyerés | Automatikus | delete szükséges
|
Használat | Lokális változók, függvényhívások | Nagy adatok, dinamikus objektumok |
🔹 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!