salir(), abortar() y afirmar()

salida()

void exit ( int status ); 

exit() termina el proceso normalmente.
estado: valor de estado devuelto al proceso padre. Generalmente, un valor de estado de 0 o EXIT_SUCCESS indica éxito, y cualquier otro valor o la constante EXIT_FAILURE se utiliza para indicar un error. exit() realiza las siguientes operaciones.
* Vacía los datos almacenados en búfer no escritos.
* Cierra todos los archivos abiertos.
* Elimina archivos temporales.
* Devuelve un estado de salida entero al sistema operativo.

La función atexit() estándar de C se puede usar para personalizar exit() para realizar acciones adicionales al finalizar el programa.

Ejemplo de uso de salida.

/* exit example */
#include <stdio.h>
#include <stdlib.h>
   
int main ()
{
  FILE * pFile;
  pFile = fopen ("myfile.txt", "r");
  if (pFile == NULL)
  {
    printf ("Error opening file");
    exit (1);
  }
  else
  {
    /* file operations here */
  }
  return 0;
}

Cuando se llama a exit(), cualquier descriptor de archivo abierto que pertenezca al proceso se cierra y cualquier hijo del proceso es heredado por el proceso 1, init, y el padre del proceso recibe una señal SIGCHLD.

El misterio detrás de exit() es que solo toma argumentos enteros en el rango de 0 a 255. Los valores de salida fuera de rango pueden generar códigos de salida inesperados. Un valor de salida superior a 255 devuelve un módulo de código de salida 256.
Por ejemplo, la salida 9999 da un código de salida de 15, es decir (9999 % 256 = 15).

A continuación se muestra la implementación de C para ilustrar el hecho anterior:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
  
int main(void)
{
    pid_t pid = fork();
      
    if ( pid == 0 )
    {
       exit(9999); //passing value more than 255
    }
  
    int status;
    waitpid(pid, &status, 0);
  
    if ( WIFEXITED(status) )
    {
        int exit_status = WEXITSTATUS(status);
          
        printf("Exit code: %d\n", exit_status);
    }
  
return 0;
}

Producción:

Exit code: 15

Tenga en cuenta que el código anterior puede no funcionar con el compilador en línea ya que fork() está deshabilitado.

Explicación: es el efecto del desbordamiento de enteros de 8 bits. Después de 255 (los 8 bits establecidos) viene 0.
Entonces, la salida es «código de salida módulo 256». La salida anterior es en realidad el módulo del valor 9999 y 256, es decir, 15.

abortar()

void abort ( void );

A diferencia de la función exit(), abort() no puede cerrar los archivos que están abiertos. Es posible que tampoco elimine los archivos temporales y que no vacíe el búfer de transmisión. Además, no llama a funciones registradas con atexit() .

Esta función en realidad termina el proceso al generar una señal SIGABRT, y su programa puede incluir un controlador para interceptar esta señal (ver esto ).

Por lo tanto, es posible que los programas como los siguientes no escriban «Geeks for Geeks» en «tempfile.txt»

#include<stdio.h>
#include<stdlib.h>
int main()
{
  FILE *fp = fopen("C:\\myfile.txt", "w");
    
  if(fp == NULL)
  {
    printf("\n could not open file ");
    getchar();
    exit(1);
  }  
    
  fprintf(fp, "%s", "Geeks for Geeks");
    
  /* ....... */
  /* ....... */
  /* Something went wrong so terminate here */  
  abort();
    
  getchar();
  return 0;  
}    

Si queremos asegurarnos de que los datos se escriban en los archivos y/o los búferes se vacíen, entonces deberíamos usar exit() o incluir un controlador de señal para SIGABRT.

afirmar()

void assert( int expression );

Si la expresión se evalúa como 0 (falso), entonces la expresión, el nombre del archivo del código fuente y el número de línea se envían al error estándar y luego se llama a la función abort(). Si el identificador NDEBUG («sin depuración») se define con #define NDEBUG, la afirmación de la macro no hace nada.

La salida de error común tiene el formato:

Aserción fallida: expresión, archivo nombre de archivo, línea número de línea

#include<assert.h>
  
void open_record(char *record_name)
{
    assert(record_name != NULL);
    /* Rest of code */
}
  
int main(void)
{
   open_record(NULL);
}

Artículo relacionado:
exit() vs _Exit() en C y C++

Este artículo es una contribución de Rahul Gupta . Escriba comentarios si encuentra algo incorrecto en el artículo anterior o si desea compartir más información sobre el tema tratado anteriormente.

Referencias:
códigos de salida
http://www.cplusplus.com/reference/clibrary/cstdlib/abort/
http://www.cplusplus.com/reference/clibrary/cassert/assert/
http://www.acm.uiuc. edu/webmonkeys/book/c_guide/2.1.html
https://www.securecoding.cert.org/confluence/display/seccode/ERR06-C.+Understand+the+termination+behavior+of+assert%28%29+ and+ abort %28%29
https://www.securecoding.cert.org/confluence/display/seccode/ERR04-C.+Elige+una+estrategia+de+terminación+apropiada