• The header <stdio.h> declares all functions that perform input and output to files and devices.
• The header <time.h> declares the functions that obtain elapsed or calendar time.
• The header <stdlib.h> declares essentially all other functions that interface with the containing environment.

#include <stdlib.h>
void abort(void);

#include <stdlib.h>
int atexit(void (*func)(void));

Forward references: the exit function (7.10.4.3).

#include <stdlib.h>
void exit(int status);

First, all functions registered by the atexit function are called, in the reverse order of their registration.128

Next, all open streams with unwritten buffered data are flushed, all open streams are closed, and all files created by the tmpfile function are removed.

Finally, control is returned to the host environment. If the value of status is zero or EXIT_SUCCESS, an implementation defined form of the status successful termination is returned. If the value of status is EXIT_FAILURE, an implementation-defined form of the status unsuccessful termination is returned. Otherwise the status returned is implementation-defined.

#include <stdlib.h>
char *getenv(const char *name);

The implementation shall behave as if no library function calls the getenv function.

#include <stdlib.h>
int system(const char *string);

Footnote

128. Each function is called as many times as it was registered.

EXIT_FAILURE — Use this macro as the argument to exit or the return value from main to report unsuccessful program termination. Any other non-zero value you use instead may have different meanings for different operating systems.

EXIT_SUCCESS — Use this macro as the argument to exit or the return value from main to report successful program termination. You can also use zero. Any other value you use may have different meanings for different operating systems.

The header <stdlib.h> also declares several functions that communicate with the environment:

atexit — Use this function to register another function to be called when the program is about to terminate. You may, for example, create a set of temporary files that you wish to remove before the program terminates. Write the function void tidy(void) to remove the files. Call atexit(&tidy) once you store the name of the first file to remove. When main returns or a function calls exit, the library calls all functions registered with atexit in reverse order of registry. The library flushes streams, closes files, and removes temporary files only after it calls all registered functions. You can register up to 32 functions with atexit.

exit — Call exit to terminate execution from anywhere within a program. Within function main you can either call exit or write a return statement. The argument to exit (or the return value for main) should be zero or EXIT_SUCCESS, described above, to report successful termination. Otherwise it should be EXIT_FAILURE, also described above.

If you plan to migrate to C++ in the future, you should probably avoid calling exit. Calling this function initiates program termination without calling the destructors for objects with dynamic storage duration. (These include arguments to function calls and declarations with storage class auto, either explicit or implicit.) That can subvert some of the tidiness, and type safety, engineered into certain classes. Get in the habit of returning from main instead. (The new exception machinery makes it easier for you to get back to main in a hurry, without bypassing the destructors.)

getenv — Use this function to obtain a pointer to the value string associated with an environment variable. (Most systems now support some form of environment variables that you can set and inspect with the command processor.) If you name an environment variable that has no definition, you get a null pointer as the value of the function. Don't alter the value string. A subsequent call to getenv can alter the string, however. To allocate a private copy, write something like:

#include <stdlib.h>

char *copyenv(const char *name)
   {  /*  get and copy environment variable */
   char *s1 = getenv(name);
   char *s2 = s1 ? malloc(strlen(s1) + 1) : NULL;
   
   return (s2 ? strcpy(s2, s1) : NULL);
   }