manual memory management

Angol

Főnév

manual memory management (tsz. manual memory managements)

1. (informatika)

A manuális memória kezelés C++-ban azt jelenti, hogy a programozónak saját magának kell lefoglalnia és felszabadítania a memóriát. Ez nagyobb kontrollt biztosít, de ha helytelenül használjuk, memóriaszivárgásokhoz, túlcsordulásokhoz és egyéb hibákhoz vezethet.

C++ nem tartalmaz automatikus szemétgyűjtőt (garbage collection, GC), mint például Java vagy Python, ezért a programozónak magának kell kezelnie a memóriát.

---

Memória területek C++-ban

A C++ memória több területre osztható:

1. Stack (Verem memória)
   • A stack memória automatikusan kezelt.
   • Lokális változók és függvényparaméterek itt tárolódnak.
   • Ha egy függvény véget ér, az adott stack memória felszabadul.
2. Heap (Kupac memória)
   • A heap memória dinamikusan foglalható és manuálisan kell felszabadítani.
   • A program futás közben használja.
   • new és delete segítségével kell kezelni.
3. Statikus memória
   • Globális és static változók itt tárolódnak.
   • A program teljes futása alatt léteznek.

---

Memória foglalás new operátorral

A new operátor dinamikusan lefoglalja a memóriát a heap-en, és visszaad egy mutatót a lefoglalt területre.

Egyszerű változó lefoglalása

#include <iostream>

int main() {
    int* ptr = new int;  // Egész szám foglalása heap-en
    *ptr = 42;

    std::cout << "Érték: " << *ptr << std::endl;

    delete ptr;  // Memória felszabadítása
}

🔹 Magyarázat:
- new int lefoglal egy egyetlen int típusú memóriaterületet.
- delete ptr felszabadítja a memóriát, hogy elkerüljük a memóriaszivárgást.

---

Memória foglalás tömbökre

Tömbök dinamikus foglalása esetén new[] és delete[] operátorokat kell használni.

Példa:

#include <iostream>

int main() {
    int* arr = new int[5];  // 5 elemű tömb foglalása a heap-en

    for (int i = 0; i < 5; i++) {
        arr[i] = i * 10;  // Értékek beállítása
    }

    for (int i = 0; i < 5; i++) {
        std::cout << arr[i] << " ";
    }

    delete[] arr;  // Tömb felszabadítása
}

Kimenet:

0 10 20 30 40

🔹 Fontos!
- Tömb esetén mindig delete[]-t kell használni, nem delete-et.

---

Memória szivárgás (Memory Leak)

A memóriaszivárgás akkor következik be, ha egy dinamikusan lefoglalt memória nem kerül felszabadításra, így az többé nem érhető el a program számára, de a RAM-ban foglal helyet.

Példa memória szivárgásra (ROSSZ KÓD!)

void memoryLeak() {
    int* ptr = new int(42);  
    // NINCS delete -> Memóriaszivárgás!
}

Mi a probléma?
- ptr mutatót nem szabadítjuk fel, így a heap-en lefoglalt memória soha nem kerül vissza az operációs rendszerhez.

Jó megoldás (felszabadítással)

void noMemoryLeak() {
    int* ptr = new int(42);
    delete ptr;  // Memória felszabadítása
}

✅ Mindig töröld a lefoglalt memóriát!

---

Vad mutatók (Dangling Pointers)

Egy mutató akkor lesz vad mutató (dangling pointer), ha az általa mutatott memória felszabadult, de még mindig rámutat.

Példa vad mutató létrejöttére

int* ptr = new int(42);
delete ptr;  // Memória felszabadítása
std::cout << *ptr;  // HIBA! ptr egy nem létező memóriaterületre mutat.

🔹 Megoldás:
1️⃣ Felszabadítás után állítsd a mutatót nullptr-ra!

delete ptr;
ptr = nullptr;

✅ Ezzel megelőzheted a véletlen hozzáféréseket.

---

smart pointer – Okosmutatók (C++11)

A C++11 bevezette a std::unique_ptr és std::shared_ptr osztályokat, amelyek automatikusan kezelik a memória felszabadítását.

std::unique_ptr – Egyedüli tulajdonú mutató

• Egyedi mutató, ami automatikusan törli az objektumot, ha elhagyja a hatókört.

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> ptr = std::make_unique<int>(42);
    std::cout << *ptr << std::endl;  
}  // Automatikusan felszabadul itt!

std::shared_ptr – Több mutató egy objektumra

• Több mutató is hivatkozhat ugyanarra az objektumra, és amikor az utolsó mutató is megszűnik, az objektum automatikusan törlődik.

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> ptr1 = std::make_shared<int>(100);
    std::shared_ptr<int> ptr2 = ptr1;  // Mindkettő ugyanarra az objektumra mutat

    std::cout << "Érték: " << *ptr1 << std::endl;
}  // Automatikus törlés, amikor az utolsó mutató megszűnik.

✅ Okosmutatók segítségével elkerülhetők a memóriaszivárgások és a vad mutatók.

---

Összegzés

C++ memória kezelésének alapelvei:

✅ Használd a new és delete operátorokat manuális memória kezeléshez.
✅ Használj delete-et minden lefoglalt memóriához!
✅ Ne felejtsd el delete[]-et használni tömbökhöz.
✅ Állítsd a mutatókat nullptr-ra törlés után, hogy elkerüld a vad mutatókat.
✅ Használj okosmutatókat (std::unique_ptr, std::shared_ptr), hogy elkerüld a memóriaszivárgásokat.

További információk

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