segmentation fault

segmentation fault (tsz. segmentation faults)

1. (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.

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

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.

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 = {1, 2, 3, 4, 5};
    std::cout << arr;  // HIBA: A tömbnek csak 5 eleme van
    return 0;
}

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

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.

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.

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.

1. Mindig inicializáljuk a pointereket!

   • Példa:

     int* ptr = nullptr;
     

   • Így biztosíthatjuk, hogy egy pointer ne mutasson véletlenszerű helyre.

2. Mindig ellenőrizzük a nullpointereket!

   • Példa:

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

3. 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
     

4. 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
     

5. Használjunk okos pointereket (std::unique_ptr, std::shared_ptr)

   • Példa:

     std::unique_ptr<int> ptr = std::make_unique<int>(10);
     

6. 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
     

• 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.

• 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)