Volcado de núcleo (fallo de segmentación) en C/C++

La falla de volcado de núcleo/segmentación es un tipo específico de error causado por el acceso a la memoria que «no le pertenece». 
 

• Cuando un fragmento de código intenta realizar una operación de lectura y escritura en una ubicación de solo lectura en la memoria o en un bloque de memoria liberado, se conoce como volcado del núcleo.
• Es un error que indica corrupción de memoria.

Escenarios comunes de errores de segmentación: 
 

• Modificación de un literal de string: 
  el siguiente programa puede fallar (da un error de falla de segmentación) porque la línea * (str + 1) = ‘n’ intenta escribir una memoria de solo lectura. 
   

// C++ program to demonstrate segmentation fault/core dump
// by modifying a string literal
 
#include <iostream>
using namespace std;
 
int main()
{
   char *str;
 
   /* Stored in read only part of data segment */
   str = "GfG";    
 
   /* Problem:  trying to modify read only memory */
   *(str + 1) = 'n';
   return 0;
}
 
// This code is contributed by sarajadhav12052009

int main()
{
   char *str;
 
   /* Stored in read only part of data segment */
   str = "GfG";    
 
   /* Problem:  trying to modify read only memory */
   *(str+1) = 'n';
   return 0;
}

Abnormal termination of program.

Consulte Almacenamiento para strings en C para obtener más  información.
 

• Acceder a una dirección que está liberada: 
  aquí, en el siguiente código, se elimina la referencia del puntero p después de liberar el bloque de memoria, lo cual no está permitido por el compilador. Por lo tanto, produce la falla del segmento de error o la terminación anormal del programa en tiempo de ejecución. 
  Ejemplo: 
   

// C++ program to illustrate
// Core Dump/Segmentation fault
#include <iostream>
using namespace std;
 
int main(void)
{
    // allocating memory to p
    int* p = (int*) malloc(8*sizeof(int));
     
    *p = 100;
     
    // deallocated the space allocated to p
    free(p);
     
    // core dump/segmentation fault
    //  as now this statement is illegal
    *p = 110;
     
    return 0;
}
 
// This code is contributed by shivanisinghss2110

// C program to illustrate
// Core Dump/Segmentation fault
#include <stdio.h>
#include<alloc.h>
int main(void)
{
    // allocating memory to p
    int* p = malloc(8);
    *p = 100;
     
    // deallocated the space allocated to p
    free(p);
     
    // core dump/segmentation fault
    //  as now this statement is illegal
    *p = 110;
     
    return 0;
}

Producción: 
 

Abnormal termination of program.

• Acceso fuera de los límites del índice de array: 
   

// C++ program to demonstrate segmentation
// fault when array out of bound is accessed.
#include <iostream>
using namespace std;
 
int main()
{
   int arr[2];
   arr[3] = 10;  // Accessing out of bound
   return 0;
}

// C program to demonstrate segmentation
// fault when array out of bound is accessed.
 
#include <stdio.h>
 
int main(void)
{
   int arr[2];
   
   arr[3] = 10;  // Accessing out of bound
   
   return (0);
}
 
// This code is contributed by sarajadhav12052009

Producción: 
 

Abnormal termination of program.

• Uso incorrecto de scanf(): 
  la función scanf() espera la dirección de una variable como entrada. Aquí, en este programa, n toma el 
  valor de 2 y asume que su dirección es 1000. Si pasamos n a scanf(), la entrada obtenida de STDIN se coloca en la memoria no válida 2, que debería ser 1000 en su lugar. Es una corrupción de memoria que conduce a una falla de segmentación. 
   

// C++ program to demonstrate segmentation
// fault when value is passed to scanf
#include <iostream>
using namespace std;
 
 
int main()
{
   int n = 2;
   cin >> " " >> n;
   return 0;
}
 
// This code is contributed by shivanisinghss2110

// C program to demonstrate segmentation
// fault when value is passed to scanf
#include <stdio.h>
 
int main()
{
   int n = 2;
   scanf(" ",n);
   return 0;
}

Producción: 
 

Abnormal termination of program.

• Stack Overflow 
  No es un problema relacionado con el puntero, incluso el código puede no tener un solo puntero. Se debe a que la función recursiva se llama repetidamente, lo que consume toda la memoria de la pila, lo que provoca un desbordamiento de la pila. Quedarse sin memoria en la pila también es un tipo de corrupción de la memoria. Se puede resolver teniendo una condición base para regresar desde la función recursiva.
   
• Desreferenciación de un puntero no inicializado 
  Un puntero debe apuntar a una memoria válida antes de acceder a ella. 
   

// C++ program to demonstrate segmentation
// fault when uninitialized pointer is accessed.
#include <iostream>
using namespace std;
 
int main()
{
    int* p;
    cout << *p;
    return 0;
}
// This code is contributed by Mayank Tyagi

// C program to demonstrate segmentation
// fault when uninitialized pointer is accessed.
#include <stdio.h>
 
int main()
{
   int *p;
   printf("%d",*p);
   return 0;
}

Este artículo es una contribución de Bishal Kumar Dubey . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.