segmentation fault

Angol

Főnév

segmentation fault (tsz. segmentation faults)

(informatika) A segmentation fault (vagy röviden segfault) az egyik leggyakoribb futásidejű hiba C++ és más alacsony szintű nyelvek esetén. A program akkor találkozik vele, amikor megpróbál egy olyan memóriaterülethez hozzáférni, amelyhez nincs engedélye.

Miért következik be a segmentation fault?

A segmentation fault akkor történik, ha egy program érvénytelen memóriahozzáférést próbál végrehajtani. Ez lehet:

Olvasás vagy írás egy érvénytelen memóriacímre
Felszabadított (dangling) pointer használata
Nullpointer dereferálása
Túlindexelés egy tömbön
Stack overflow (például végtelen rekurzió miatt)
Nem inicializált pointer használata
ROM terület módosítása

Gyakori okok és példák

1. Nullpointer dereferálás

Ez az egyik leggyakoribb hiba: amikor egy pointer nullptr-ra mutat, és megpróbáljuk használni.

#include <iostream>

int main() {
    int* ptr = nullptr; // Pointer nem mutat sehova
    std::cout << *ptr;  // HIBA: Nullpointer dereferálása
    return 0;
}

Ebben az esetben a program egy nem létező memóriahelyről próbál olvasni, ami segmentation faultot eredményez.

2. Tömb túlindexelése

Ha egy tömbön kívüli memóriaterülethez próbálunk hozzáférni, az is segfaultot okozhat.

#include <iostream>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    std::cout << arr[10];  // HIBA: A tömbnek csak 5 eleme van
    return 0;
}

A arr[10] memóriahelyen kívül van, így az eredmény ismeretlen, és segmentation fault léphet fel.

3. Dinamikus memória rossz kezelése

Ha felszabadított memóriát próbálunk használni, az is hibát eredményez.

#include <iostream>

int main() {
    int* ptr = new int(5);
    delete ptr;  // Felszabadítjuk a memóriát

    std::cout << *ptr;  // HIBA: Dangling pointer
    return 0;
}

A delete után a ptr még mindig létezik, de a memóriaterület már nem érvényes.

4. Nem inicializált pointer használata

Ha egy pointert létrehozunk, de nem inicializáljuk, akkor véletlenszerű memóriacímre mutathat.

#include <iostream>

int main() {
    int* ptr;  // Nem inicializált pointer
    *ptr = 10; // HIBA: Véletlenszerű helyre írunk
    return 0;
}

Mivel ptr egy ismeretlen memóriahelyre mutat, a program leállhat segmentation faulttal.

5. Végtelen rekurzió (Stack Overflow)

Ha egy függvény végtelen rekurzióba kerül, akkor a stack memória elfogy, és segmentation fault történik.

void recursiveFunction() {
    recursiveFunction();  // Nincs kilépési feltétel
}

int main() {
    recursiveFunction();  // Stack overflow!
    return 0;
}

A program addig hívogatja önmagát, amíg a stack ki nem merül.

Hogyan előzzük meg a segmentation faultot?

Mindig inicializáljuk a pointereket!
- Példa:
```
int* ptr = nullptr;
```
- Így biztosíthatjuk, hogy egy pointer ne mutasson véletlenszerű helyre.

Mindig ellenőrizzük a nullpointereket!

Példa:

if (ptr != nullptr) {
    std::cout << *ptr;
}

Ne lépjünk túl a tömb határain!
- Használjunk std::vector-t nyers tömbök helyett, mert biztonságosabb.
- Példa:
```
std::vector<int> v = {1, 2, 3};
std::cout << v.at(5);  // Ez kivételt dob, nem segmentation faultot
```

Ne használjunk felszabadított memóriát!

Példa:

int* ptr = new int(10);
delete ptr;
ptr = nullptr;  // Biztonságosabb, mert nem tudunk rossz memóriát elérni

Használjunk okos pointereket (std::unique_ptr, std::shared_ptr)
- Példa:
```
std::unique_ptr<int> ptr = std::make_unique<int>(10);
```
Használjunk valgrind vagy AddressSanitizer eszközöket a hibák keresésére
- valgrind futtatása:
```
valgrind ./program
```
- AddressSanitizer (fordítás GCC/Clang alatt):
```
g++ -fsanitize=address main.cpp -o main
```

Összegzés

A segmentation fault egy memóriahozzáférési hiba.
Oka lehet: nullpointer dereferálás, túlindexelés, felszabadított memória használata, stack overflow.
Elkerülhető okos pointerekkel, megfelelő inicializálással, tömbméret ellenőrzéssel, és hibakereső eszközök használatával.

Ha még mindig segmentation faulttal találkozol, a debugger (pl. gdb) segíthet a hiba helyének pontos meghatározásában:

gdb ./program
run
backtrace

Ez megmutatja, hogy pontosan hol omlott össze a program.

További információk

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