Como descobrir o que está causando um erro SIGSEGV no meu código

SIGSEGV (abreviado de violação de segmentação) é enviado para o processo ofensivo.

Causas

As condições sob as quais as violações de segmentação ocorrem e como elas se manifestam são específicas do hardware e do sistema operacional:

diferentes hardware levanta diferentes falhas para determinadas condições, e diferentes sistemas operacionais convertem-nas em diferentes sinais que são passados para processos.
A causa próxima é uma violação de acesso à memória, enquanto a causa subjacente é geralmente um bug de software de algum tipo.

Determinar a causa raiz - depuração do bug - pode ser simples em alguns casos, onde o programa irá consistentemente causar uma falha de segmentação (por exemplo, dereferenciando um ponteiro nulo), enquanto em outros casos o bug pode ser difícil de reproduzir e depender da alocação de memória em cada execução (por exemplo, desreferenciando um ponteiro suspenso).
As seguintes são algumas das causas típicas de um erro de segmentação:
<

• >li>Dereferenciação de apontadores NULL - isto é feito por hardware de gerenciamento de memória>li>Attempting para acessar um endereço de memória inexistente (fora do processo's address space)>li>Attempting to access memory the program does not have rights to (such as kernel structures in process context)>li>li>Attempting to write read-only memory (such as code segment)

Estes, por sua vez, são frequentemente causados por erros de programação que resultam em acessos inválidos à memória:
<

>ul>Dereferenciar ou atribuir a um ponteiro não inicializado (ponteiro selvagem, que aponta para um endereço de memória aleatório)>li>li>Dereferenciar ou atribuir a um ponteiro liberado (ponteiro pendular, que aponta para uma memória que foi liberada/desalocada/apagada)li>Um buffer overflow>li>Um stack overflow>li>Attempting to execute a programmation that does not compile correctly. (Alguns compiladores irão emitir um arquivo executável apesar da presença de erros em tempo de compilação.)

No código C, falhas de segmentação ocorrem mais frequentemente devido a erros no uso do ponteiro, particularmente na alocação dinâmica de memória C. Dereferenciar um ponteiro nulo sempre resultará em uma falha de segmentação, mas ponteiros selvagens e ponteiros pendulares apontam para memória que pode ou não existir, e pode ou não ser legível ou escrevível, e assim pode resultar em bugs transitórios. Por exemplo:
char *p1 = NULL; // Ponteiro nulo
char *p2; // Ponteiro selvagem: não inicializado de forma alguma.
char *p3 = malloc(10 * sizeof(char)); // ponteiro inicializado para memória alocada
// (assumindo que malloc não falhou)

free(p3); // p3 é agora um ponteiro pendular, pois a memória foi liberada

>Agora, o desreferenciamento de qualquer uma destas variáveis pode causar uma falha de segmentação: A desreferenciação do ponteiro nulo geralmente causará uma segregação, enquanto a leitura do ponteiro selvagem pode resultar em dados aleatórios mas sem segregação, e a leitura do ponteiro suspenso pode resultar em dados válidos por um tempo, e então dados aleatórios à medida que são sobregravados.