manual memory management (tsz. manual memory managements)
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.
A C++ memória több területre osztható:
new
és delete
segítségével kell kezelni.static
változók itt tárolódnak.
new
operátorralA new
operátor dinamikusan lefoglalja a memóriát a heap-en, és visszaad egy mutatót a lefoglalt területre.
#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.
Tömbök dinamikus foglalása esetén new
és delete
operátorokat kell használni.
#include <iostream>
int main() {
int* arr = new int; // 5 elemű tömb foglalása a heap-en
for (int i = 0; i < 5; i++) {
arr = i * 10; // Értékek beállítása
}
for (int i = 0; i < 5; i++) {
std::cout << arr << " ";
}
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.
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.
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.
void noMemoryLeak() {
int* ptr = new int(42);
delete ptr; // Memória felszabadítása
}
✅ Mindig töröld a lefoglalt memóriát!
Egy mutató akkor lesz vad mutató (dangling pointer), ha az általa mutatott memória felszabadult, de még mindig rámutat.
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ó#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#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.
✅ 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.