C Programming/stdlib.h/exit

On many computer operating systems, a computer process terminates its execution by making an exit system call. More generally, an exit in a multithreading environment means that a thread of execution has stopped running. The operating system reclaims resources (memory, files, etc.) that were used by the process. The process is said to be a "dead process" after it terminates.
How it works.
Under Unix and Unix-like operating systems, a process is started when its parent process executes a "fork" system call. The parent process may then wait for the child process to terminate, or may continue execution (possibly forking off other child processes). When the child process terminates ("dies"), either normally by calling "exit", or abnormally due to a fatal error or signal (e.g., SIGTERM, SIGINT, SIGKILL), an exit status is returned to the operating system and a SIGCHLD signal is sent to the parent process. The exit status can then be retrieved by the parent process via the "wait" system call.
Most operating systems allow the terminating process to provide a specific exit status to the system, which is made available to the parent process. Typically this is a small integer value, although some operating systems (e.g.,Plan 9) allow a character string to be specified.
Clean up.
The exit operation typically performs clean-up operations within the process space before returning control back to the operating system. Some systems and programming languages allow user subroutines to be registered so that they are invoked at program termination before the process actually terminates for good. As the final step of termination, a primitive system exit call is invoked, informing the operating system that the process has terminated and allows it to reclaim the resources used by the process.
It is sometimes possible to bypass the usual cleanup; C99 offers the codice_1 function which terminates the current process without any extra program clean-up. This may be used, for example, in a fork-exec routine when the codice_2 call fails to replace the child process; calling codice_3 routines would erroneously release resources belonging to the parent.
Orphans and zombies.
Some operating systems handle a child process whose parent process has terminated in a special manner. Such an "orphan process" becomes a child of a special "root process", which then waits for the child process to terminate. Likewise, a similar strategy is used to deal with a "zombie process", which is a child process that has terminated but whose exit status is ignored by its parent process. Such a process becomes the child of a special parent process, which retrieves the child's exit status and allows the operating system to complete the termination of the dead process. Dealing with these special cases keeps the system process table in a consistent state.
Examples.
The following programs terminate and return a success exit status to the system.
C:
int main(void)
 exit(EXIT_SUCCESS);
or:
int main(void)
 return EXIT_SUCCESS;
C++:
int main(void)
 std::exit(EXIT_SUCCESS); // or return EXIT_SUCCESS
COBOL:
 IDENTIFICATION DIVISION.
 PROGRAM-ID. SUCCESS-PROGRAM.
 PROCEDURE DIVISION.
 MAIN.
 MOVE ZERO TO RETURN-CODE.
 END PROGRAM.
Java:
public class Success
 public static void main(String[] args)
 System.exit(0);
DOS Batch file:
exit 0
Perl:
exit;
PHP:
&lt;?php
exit(0);
Python:
import sys
sys.exit(0)
Unix shell:
exit 0
Pascal:
program pr1;
begin
 exit(0);
end;
DOS Assembly:
 ; For MASM/TASM
 .MODEL SMALL
 .STACK
 .CODE
 main PROC NEAR
 MOV AH, 4Ch ; Service 4Ch - Terminate with Error Code
 MOV AL, 0 ; Error code
 INT 21h ; Interrupt 21h - DOS General Interrupts
 main ENDP
 END main ; Starts at main
Some programmers may prepare everything for INT 21h at once:
 MOV AX, 4C00h ; replace the 00 with your error code in HEX
Linux Assembly:
 ; For NASM
 MOV AL, 1 ; Function 1: exit()
 MOV EBX, 0 ; Return code
 INT 80h ; The only interrupt Linux uses!
 # For GAS
 .text
 .globl _start
 _start:
 movl $1, %eax # System call number 1: exit()
 movl $0, %ebx # Exits with exit status 0
 int $0x80 # Passes control to interrupt vector
 # invokes system call—in this case system call
 # number 1 with argument 0