Quote the differences between exit, return, _exit, and _Exit functions

1. The main difference between the exit function and the return function is:

exit is used to end the program at any time while the program is running, and its parameters are returned to the OS. It can also be said that the exit function exits the application and returns a status of the application to the OS. This status identifies some running information of the application.

The exit function will also be called implicitly when the main function ends. When the exit function is running, it will first execute the function registered by the atexit() function, and then do some cleaning work of its own, while refreshing all output streams and closing all open ones. Stream and close the temporary file created by the standard I/O function tmpfile().

exit is a system call level. It indicates the end of a process. It will delete the memory space used by the process and return error information to the parent process. Usually: exit(0) indicates that the program is normal, exit(1) and exit(-1) indicate that the program exited abnormally, and exit(2) indicates that the system cannot find the specified file.

return is at the language level, it represents the return of the call stack; return is to return the function value and exit the function, usually 0 is a normal exit, non-0 is an abnormal exit, please note that if it is in the main function main, naturally This ends the current process (that is, in main(), you can use return n, or you can directly use exit(n) to do it). If it is not in the main function, it will return to the previous call. When there are multiple processes, if you sometimes want to detect whether the previous process exited normally, you need to use the return value of the previous process.

2. Process environment and process control

If exit(int n) is called in the main function, then exit(int n) will directly exit the program and return an int value. Generally, under the shell, run a program, and then use the command echo $? to get the return value of the program, which is the exit value. Theoretically, exit can return any integer less than 256. The different values ​​returned are mainly for different processing by the caller.

For a single process, the return value of exit is returned to the operating system, but if it is a multi-process, it is returned to the parent process. Call functions such as waitpid() in the parent process to obtain the exit status of the child process for different processing. Let the caller perform corresponding processing according to the corresponding return value.

In general, exit (int n) means that the current process returns its control to the main program that called the subroutine. The return value in parentheses tells the calling program the running status of the program.

1. The beginning of the process:

The C program starts execution from the main function. The prototype is as follows:

int main(int argc， char *argv[]);

Usually the return value of main is int type, and 0 is returned correctly.

2. Process termination:

C program termination is divided into two types: normal termination and abnormal termination.

Normal termination is divided into: return, exit, _exit, _Exit, pthreade_exit.

Exception middle finger is divided into: abort, SIGNAL, thread response cancellation.

Mainly talk about the first four types of normal termination, that is, the exit series of functions.

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

The difference between the above three functions is:

exit() (or return 0) will call the termination handler and the standard I/ of user space O cleanup program (such as fclose), while _exit and _Exit are not called and are directly taken over by the kernel for cleaning. Therefore, exit(0) in the main function is equivalent to return 0.

3. atexit termination handler:

ISO C stipulates that a process can register up to 32 termination handler functions. These functions are automatically called by exit in the reverse order of registration. If the same function is registered multiple times, it will also be called multiple times.

The prototype is as follows:

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

其中参数是一个函数指针， 指向终止处理函数， 该函数无参无返回值。atexit函数本身成功调用后返回0。

以下面的程序为例:

#include <stdlib.h> static void myexit1()
{ printf("first exit handlern");
} static void myexit2()
{ printf("second exit handlern");
} int main()
{
atexit(my_exit2);
atexit(my_exit1);
atexit(my_exit1); printf("main is donen"); return 0; // 相当于exit(0) }

运行结果:

$ ./a.out
main is done first exit handler first exit handler second exit handler

main函数结束时也会隐式地调用exit函数，exit函数运行时首先会执行由atexit()函数登记的函数，然后会做一些自身的清理工作，同时刷新所有输出流、关闭所有打开的流并且关闭通过标准I/O函数tmpfile()创建的临时文件。

注意上面程序的结果，可以发现这些函数由exit按登记相反的顺序自动调用（先myexit1后myexit2）。如果同一函数登记多次， 也会被调用多次（如这里的myexit1）。

而这些处理函数都是在程序退出的时候利用atexit函数调用了这些处理函数。但是如果用_exit()退出程序，则它不关闭任何文件，不清除任何缓冲器、也不调用任何终止函数！