Segmentation Fault en C++ : causes, débogage et comment l'éviter

Segmentation Fault : pas seulement une erreur, mais une porte vers le monde de la mémoire en C++

Si vous avez déjà programmé en C++ et vu dans le terminal le message court mais effrayant Segmentation fault (core dumped), vous n'êtes pas seul. Ce signal est l'un des ennemis les plus courants des développeurs débutants (et expérimentés). Sur Stack Overflow, la question "What is a segmentation fault?" a recueilli des centaines de milliers de vues. Mais derrière cette erreur se cache quelque chose de plus profond : une compréhension approfondie du fonctionnement de la mémoire, des pointeurs et des performances de votre code.

Dans cet article, nous ne nous contenterons pas d'expliquer ce qu'est un segfault. Nous apprendrons à le trouver, à le corriger et, surtout, à le prévenir. Nous verrons également comment cette erreur est liée à l'optimisation du code et pourquoi son apparition peut indiquer des problèmes de performances.

Qu'est-ce qu'une erreur de segmentation en termes simples ?

Segmentation fault (erreur de segmentation) est un signal que le système d'exploitation envoie à votre programme : « Tu essaies d'accéder à une mémoire qui ne t'appartient pas ». Imaginez que vous louez un appartement (votre processus) et que vous essayez soudainement d'entrer chez le voisin à travers le mur. La sécurité (le système d'exploitation) vous arrête et vous expulse du bâtiment.

En C++, cela se produit lorsque le programme accède à une adresse mémoire invalide. Par exemple, à un pointeur nul, à une mémoire déjà libérée ou en dehors des limites d'un tableau. Contrairement à Java ou Python, où une machine virtuelle gère la sécurité de la mémoire, le C++ vous donne un contrôle total. Et avec le contrôle vient la responsabilité.

À quoi cela ressemble-t-il dans le code ?

#include <iostream>

int main() {    int* ptr = nullptr;  // pointeur nul    *ptr = 42;           // segmentation fault !    return 0;}

À première vue, l'erreur est évidente. Mais dans les projets réels, les causes sont beaucoup plus sournoises. Examinons-les dans l'ordre.

Top 5 des causes d'erreur de segmentation en C++

1. Déréférencement d'un pointeur nul

La cause la plus fréquente et la plus compréhensible. Le pointeur ne pointe vers aucun objet, et vous essayez d'écrire ou de lire des données à cette adresse.

int* p = nullptr;std::cout << *p;  // segfault

Comment l'éviter : vérifiez toujours les pointeurs avant de les utiliser :

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

2. Dépassement des limites d'un tableau

Le C++ ne vérifie pas les indices des tableaux. Si vous accédez à arr[100] alors que le tableau est prévu pour 10 éléments, vous lisez ou écrivez dans une mémoire qui ne vous appartient pas.

int arr[10];arr[15] = 5;  // segfault potentiel

C'est particulièrement insidieux, car l'erreur peut ne pas se manifester immédiatement, mais surgir plus tard dans un endroit complètement différent du programme. Ces bogues sont très difficiles à déboguer.

3. Utilisation après libération (use-after-free)

Vous avez libéré la mémoire (delete ou free), mais vous continuez à utiliser le pointeur vers celle-ci. La mémoire a peut-être déjà été attribuée à un autre processus ou écrasée.

int* ptr = new int(10);delete ptr;*ptr = 20;  // segfault — utilisation après libération

Conseil : après delete, assignez nullptr au pointeur.

delete ptr;ptr = nullptr;

4. Débordement de pile (stack overflow)

Bien que ce ne soit pas un segfault classique, le débordement de pile conduit souvent au même signal. Cela se produit lorsque vous créez trop de variables locales ou que vous entrez dans une récursion infinie.

void infinite() {    int huge[1000000];  // tableau trop grand sur la pile    infinite();          // récursion sans sortie}

5. Utilisation incorrecte de reinterpret_cast

Le transtypage en C++ est un outil puissant mais dangereux. Si vous interprétez mal la mémoire, le segfault ne se fera pas attendre.