Ugrás a tartalomhoz

static memory allocation

A Wikiszótárból, a nyitott szótárból

Angol


Főnév

static memory allocation (tsz. static memory allocations)

  1. (informatika) A statikus memóriafoglalás azt jelenti, hogy a program fordítási időben (compile time) vagy linkelési időben foglal le memóriát egy adott változó vagy adattároló számára.
  • A memória nem futási időben (runtime) kerül lefoglalásra.
  • A lefoglalt memória helye és mérete előre ismert.
  • A program teljes futása alatt a memóriafoglalás változatlan marad → ugyanazon a helyen lesz elérhető.


Szemben dinamikus memóriafoglalással

Statikus memóriafoglalás Dinamikus memóriafoglalás
Compile time Runtime
Előre ismert méret Futás közben határozott
Általában stack vagy data segment Heap-en foglalódik
Nem igényel malloc/free malloc/free, new/delete


Hol használunk statikus memóriafoglalást?

1️⃣ Globális változók

2️⃣ Static kulcsszóval megjelölt változók

3️⃣ Függvény lokális nem-dinamikus változói (stack)

4️⃣ Constexpr / compile-time állandók


1️⃣ Globális változók

Globális változók program indításakor létrejönnek, és program végéig léteznek.

int counter = 0;  // statikus memória a data segmentben

A counter az adat-szegmensben van, nem a stack-en vagy heap-en.


2️⃣ Static kulcsszó

A static kulcsszó lehetővé teszi, hogy:

  • egy változó statikus élettartamú legyen, akkor is ha például függvényben van deklarálva.
void myFunction() {
    static int callCount = 0;
    callCount++;
    std::cout << "Called " << callCount << " times.\n";
}
  • A callCount nem jön létre újra minden híváskor → egyszer jön létre, program végéig megmarad.


3️⃣ Stack változók (lokális változók)

Bár a stack memória futási időben foglalódik, a lokális nem-dinamikus változók fix méretűek → a fordító előre tudja a méretüket → ez is “statikus” memória értelmezés szerint (nem dinamikusan foglalt).

void foo() {
    int x = 5;  // automatikus, de statikus méret
}
  • x a stack-en jön létre, de a mérete compile time ismert → nem dinamikus memória.


4️⃣ Compile-time állandók (const, constexpr)

Ezek is tipikus példák:

constexpr int MaxValue = 1000;
const double Pi = 3.14159;
  • Ezek az értékek fordítási időben ismertté válnak, általában nem is kerülnek a memória-ba, hanem a kódba kerülnek beégetve (inlined).


Összegzés

👉 Statikus memóriafoglalás: amikor egy programban a memóriafoglalás:

  • compile time ismert
  • előre rögzített méretű
  • a memória helye nem változik futás közben.

👉 Jellemző példák:

  • Globális és static változók → data segment
  • Lokális, fix méretű változók → stack
  • Constexpr, const → általában a kódba vagy read-only data segmentbe.

👉 Szemben a dinamikus memóriafoglalással, ahol:

  • a memória mérete futási időben határozódik meg,
  • a memória heap-en kerül lefoglalásra,
  • kézzel kell felszabadítani (pl. free() vagy delete).


Előnyök

✅ Gyors hozzáférés → nincs futási időbeli allokációs költség.

✅ Egyszerű → nincs szükség malloc/free kezelésére.

✅ Determinista → mindig ugyanakkora memóriahasználat.


Hátrányok

❌ Rugalmatlan → nem lehet futás közben változtatni a méretet.

❌ Túlméretezés veszélye → ha túl nagy statikus változókat használsz, az befolyásolhatja a program teljes memóriafogyasztását.

❌ Thread safety → globális / static változókkal óvatosan kell bánni többszálúság (multithreading) esetén, mert minden szál közösen használja őket.


Példa — Összehasonlítás

Statikus memória:

static int count = 0;  // data segment → statikus memória

Dinamikus memória:

int* arr = (int*) malloc(100 * sizeof(int));  // heap → dinamikus memória
free(arr);

Tipikus használati helyzetek

✅ Konstansok → pl. buffer méretek, max értékek.

✅ Globális állapotok (óvatosan!).

✅ Függvényhívás-számlálók → static lokális változóval.

✅ Stack-es lokális változók → kis, gyors ideiglenes adattárolás.


További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=static_memory_allocation&oldid=3500234”