new
Kiejtés
Melléknév
new
A new kulcsszó a C++ egyik legfontosabb eszköze a dinamikus memóriafoglalásra. Ezzel tudunk futásidőben (runtime) memóriát foglalni az operációs rendszertől a heap (kupac) memóriában.
1. Mi az a new?
A new egy operátor, amely: - Memóriát foglal a heap-en (nem a stack-en). - Visszatér egy pointerrel, amely a lefoglalt memória címére mutat. - Konstruktorokat is meghív, ha osztálypéldányt hozunk létre.
Példa:
int* ptr = new int(10); // Egy `int` foglalása és inicializálása 10-re
Ebben a példában: - A new int(10) egy egész számnyi memóriát foglal a heap-en. - Az int(10) inicializálja az értékét 10-re. - A ptr egy pointer, amely erre a memóriaterületre mutat.
2. Miért van szükség a new-ra?
Normál változók a stack memóriában tárolódnak:
void fuggveny() {
int x = 5; // Stack memóriában van, automatikusan felszabadul
}
Ezzel szemben a new operátor által lefoglalt memória a heap memóriában van, és nem szabadul fel automatikusan.
Előnyei: - Nagy adatszerkezeteket hozhatunk létre, amelyek túl nagyok a stack-re. - Futásidőben foglalhatunk memóriát, amikor még nem tudjuk előre a méretet. - Objektumokat hozhatunk létre dinamikusan, amelyek érvényesek maradnak a függvény visszatérése után is.
3. Egyszerű használat
Egyszerű típusok foglalása
int* szam = new int; // Dinamikusan foglalt `int`
*szam = 42; // Értékadás
cout << *szam << endl; // 42
delete szam; // Fontos! A memória felszabadítása
Ha elfelejtjük a delete utasítást, memóriaszivárgás léphet fel!
4. Tömbök foglalása a new[] operátorral
Ha egy tömböt akarunk létrehozni, a new[] operátort kell használni:
int* tomb = new int[5]; // 5 elemű tömb a heap-en
for (int i = 0; i < 5; i++) {
tomb[i] = i * 10;
}
for (int i = 0; i < 5; i++) {
cout << tomb[i] << " "; // 0 10 20 30 40
}
delete[] tomb; // Felszabadítás
A tömbök esetében a delete[] operátort kell használni, nem csak delete-et!
5. Osztálypéldányok létrehozása new segítségével
A new kulcsszó osztályok példányosítására is használható.
Egyszerű osztálypéldány létrehozása
class Auto {
public:
string marka;
Auto(string m) { marka = m; }
void info() { cout << "Márka: " << marka << endl; }
};
int main() {
Auto* a = new Auto("Toyota"); // Objektum a heap-en
a->info(); // Márka: Toyota
delete a; // Memória felszabadítása
return 0;
}
A -> operátorral érhetjük el a tagfüggvényeket.
6. Tömbök osztályokkal és new[]-al
Ha több objektumot akarunk létrehozni:
class Auto {
public:
string marka;
Auto() { marka = "Ismeretlen"; }
};
int main() {
Auto* autok = new Auto[3]; // 3 objektum a heap-en
autok[0].marka = "Toyota";
autok[1].marka = "BMW";
autok[2].marka = "Audi";
for (int i = 0; i < 3; i++) {
cout << autok[i].marka << endl;
}
delete[] autok; // Fontos!
return 0;
}
Fontos: Ha egy tömböt hozunk létre osztálypéldányokkal, akkor minden objektumnál a default constructor (alapértelmezett konstruktor) fog lefutni.
7. new és konstruktorok
A new nemcsak memóriát foglal, hanem meghívja az osztály konstruktorát is.
class Ember {
public:
string nev;
Ember(string n) { nev = n; cout << "Konstruktor lefut: " << nev << endl; }
};
int main() {
Ember* e = new Ember("Gábor"); // Konstruktor hívódik
delete e;
return 0;
}
Kimenet:
Konstruktor lefut: Gábor
8. delete és destruktorok
A delete operátor meghívja az objektum destruktorát (~ClassName).
Példa:
class Ember {
public:
string nev;
Ember(string n) { nev = n; }
~Ember() { cout << nev << " destruktora meghívva!" << endl; }
};
int main() {
Ember* e = new Ember("Anna");
delete e; // Destruktor lefut
return 0;
}
Kimenet:
Anna destruktora meghívva!
Ha tömböt hozunk létre objektumokkal, akkor a delete[] biztosítja, hogy minden objektum destruktora lefusson.
9. Memóriaszivárgás (memory leak)
Ha elfelejtjük a delete-et, a memória soha nem szabadul fel:
void fuggveny() {
int* p = new int(100);
} // A memória SOHA nem szabadul fel!
A p pointer elveszik, de a memória foglalt marad → memóriaszivárgás!
Megoldás: Mindig használjunk delete-et.
10. smart pointer megoldás (unique_ptr és shared_ptr)
A modern C++ (C++11-től) bevezette az okos pointereket (std::unique_ptr, std::shared_ptr), amelyek automatikusan felszabadítják a memóriát.
unique_ptr használata
#include <memory>
int main() {
unique_ptr<int> p = make_unique<int>(42);
cout << *p << endl; // 42
return 0;
} // Automatikusan felszabadul!
shared_ptr használata
#include <memory>
int main() {
shared_ptr<int> p1 = make_shared<int>(42);
shared_ptr<int> p2 = p1; // Több shared_ptr osztozik rajta
cout << *p1 << ", " << *p2 << endl; // 42, 42
return 0;
} // Automatikusan felszabadul, amikor az utolsó shared_ptr törlődik.
Összegzés
| Tulajdonság | Magyarázat |
|---|---|
new
|
Memóriát foglal a heap-en, és visszaad egy pointert |
delete
|
Felszabadítja a new által foglalt memóriát
|
new[] / delete[]
|
Tömbök kezelésére használatos |
| Smart pointerek | unique_ptr, shared_ptr automatikusan kezeli a memóriát
|
| Memóriaszivárgás veszély | Ha elfelejtjük a delete-et
|
A new használata hatékony, de veszélyes lehet. Modern C++-ban érdemes smart pointereket használni! 🚀