stack memory

Kategória:angol-magyar szótár#STACK%20MEMORY

Angol


Főnév

stack memory (tsz. stack memories)Kategória:angol lemmák#STACK%20MEMORYKategória:angol főnevek#STACK%20MEMORYKategória:angol megszámlálható főnevek#STACK%20MEMORYKategória:angol kifejezések#STACK%20MEMORY

  1. (informatikaKategória:en:Informatika#STACK%20MEMORY) 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.


1. A memória felosztása C++ programokban

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.


2. Stack memória működése C++ nyelven

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;
}

Lépések a stack memóriában:

  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.


3. Stack frame (veremkeret) magyarázata

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.

Példa:

#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.


4. Stack memória korlátozásai

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.

4.1. Stack overflow végtelen rekurzió miatt

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);
}

4.2. Stack overflow nagy lokális változók miatt

void nagyTomb() {
    int tomb[1000000]; // 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[1000000]; // Heap használata
    delete[] tomb;
}

5. Stack memória vs Heap memória

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

Mikor használjunk heap memóriát?

  • 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.


6. Stack méret növelése C++ programokban

Windows (Visual Studio)

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.

Linux (g++)

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.


7. Összegzés

🔹 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.

További információk

Kategória:angol-magyar szótár Kategória:angol főnevek Kategória:angol kifejezések Kategória:angol lemmák Kategória:angol megszámlálható főnevek Kategória:en Kategória:en:Informatika