C++ new and delete

Angol

Főnév

C++ new and delete (tsz. C++ new and deletes)

1. (informatika) 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! 🚀

További információk

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