stack memory (tsz. stack memories)
A programok memóriahasználata általában négy fő területre oszlik:
new
, delete
használatával).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;
}
main()
függvény meghívása – a a
változó a stackbe kerül.fuggveny1(a)
hívása – új stack frame jön létre a x
és y
változóknak.fuggveny1
befejeződik, és a x
és y
változók törlődnek a stackből.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;
}
Tulajdonság | Stack memória | Heap memória |
---|---|---|
Sebesség | Nagyon gyors | Lassabb |
Foglalás módja | Automatikus | Manuális (new és delete )
|
Méret | Korlátozott | Nagyobb |
Visszanyerés | Automatikus törlés | delete szükséges
|
Használat | Lokális változók, függvényhívások | Nagy vagy dinamikus adatok |
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.