null pointer

Angol

Főnév

null pointer (tsz. null pointers)

(informatika) A null pointer fogalma a C++ programozásban (és más nyelvekben is) alapvető fontosságú, különösen, ha dinamikus memóriakezeléssel dolgozunk. Bár elsőre egyszerűnek tűnhet — „egy pointer, ami semmire sem mutat” —, mégis az egyik leggyakoribb hiba- és összeomlásforrás a programokban.

🔹 Mi az a pointer?

A pointer egy olyan változó, amely egy másik változó memóriacímét tárolja. Ha például van egy int a = 5;, és egy int* ptr = &a;, akkor a ptr változó a a címét tárolja.

int a = 5;
int* ptr = &a;

Ebben a példában a ptr mutatóként funkcionál. A *ptr dereferálással elérhetjük azt az értéket, amelyre mutat (azaz 5-öt).

🔹 Mi az a null pointer?

A null pointer egy speciális pointer, amely nem mutat semmilyen érvényes memóriacímre. Általában azt jelenti: „ez a pointer jelenleg nincs beállítva egyetlen objektumra sem”.

int* ptr = nullptr;

A nullptr C++11 óta használható kulcsszó, amelyet azelőtt a NULL vagy a 0 érték helyettesített:

int* ptr = NULL;  // régi stílus (C és C++98)
int* ptr = 0;     // szintén használható, de nem ajánlott

🔹 Miért van szükség null pointerre?

A null pointer célja az, hogy egyértelműen jelezze: a mutató jelenleg nem mutat semmire. Ez segíti a hibakeresést és a feltételes logikát:

if (ptr == nullptr) {
    std::cout << "A pointer nincs inicializálva.\n";
}

Ez különösen fontos dinamikusan lefoglalt memória kezelésekor, például:

int* arr = new int[10];
// használat
delete[] arr;
arr = nullptr; // fontos: így tudjuk jelezni, hogy a memória már felszabadult

🔹 Mi történik, ha dereferáljuk a null pointert?

Végzetes hiba: ha egy null pointert dereferálunk (*ptr), akkor a program összeomlik — undefined behavior, ami legtöbbször segmentation fault-hoz vezet.

int* ptr = nullptr;
std::cout << *ptr;  // ⚠️ HIBA! Null pointer dereferálása

Ezért mindig ellenőrizni kell, hogy a pointer nem nullptr, mielőtt használjuk.

🔹 Mikor lehet egy pointer null?

Inicializáláskor:
```
int* p = nullptr;
```
Memória felszabadítás után:
```
delete p;
p = nullptr;
```

Hibás függvényhívás eredményeként:

int* keres(int arr[], int size, int keresett) {
    for (int i = 0; i < size; ++i)
        if (arr[i] == keresett) return &arr[i];
    return nullptr;  // ha nem található
}

🔹 A `nullptr` vs `NULL` vs `0`

nullptr (C++11): típusos null pointer literál (std::nullptr_t)
NULL: makró, tipikusan #define NULL 0, nem típusos
0: numerikus érték, amely szintaktikusan elfogadott pointerként, de nem kifejező

Például az alábbi túlterhelt függvény esetén nullptr nélkül nem tudnánk eldönteni, melyik hívódjon meg:

void f(int);
void f(int*);

f(0);        // az int verzió hívódik meg
f(nullptr);  // az int* verzió hívódik meg (típus alapján)

🔹 Használati példák

Függvények, amelyek null pointert adhatnak vissza

Sok függvény visszatérési értéke lehet null pointer, ha valamilyen hibát vagy hiányt jelez:

char* strchr(const char* str, int ch);
// ha a karakter nem található meg, visszatér nullptr-rel

Osztálybeli tagok inicializálása

class Node {
public:
    int data;
    Node* next;

    Node(int d) : data(d), next(nullptr) {}
};

🔹 Null pointer mint hibakezelés

C++-ban nincs beépített kivételmechanizmus a legtöbb nyelvi elemhez, így gyakori minta, hogy egy hiba esetén nullptr-t ad vissza a függvény:

User* findUserById(int id) {
    if (adatbazisban_van(id))
        return new User(id);
    return nullptr;
}

És ezt így ellenőrizzük:

User* u = findUserById(42);
if (u == nullptr) {
    std::cerr << "Nincs ilyen felhasználó!";
}

🔹 Null pointer az okos pointerek világában

A modern C++ programozásban inkább okos pointereket használunk (std::unique_ptr, std::shared_ptr). Ezek is támogathatják a null értéket:

std::unique_ptr<int> ptr;
if (!ptr) {
    std::cout << "Üres unique_ptr\n";
}

🔹 Null pointer és tömbök

int* arr = nullptr;
if (arr) {
    for (int i = 0; i < 10; ++i)
        std::cout << arr[i];  // biztonságos, mert csak ha nem nullptr
}

🔹 Hibák, amiket elkerülhetsz null pointerrel

Dupla delete:

delete ptr;
delete ptr;  // ha nem nullptr-re állítod be előtte, ez undefined behavior

→ Megoldás:

delete ptr;
ptr = nullptr;

Elfelejtett inicializálás:

int* p;  // nem inicializált, lehet szemét érték!