Main function

 

C

Language

Standard Library

Type support

Dynamic memory management

Error handling

Program utilities

Date and time utilities

Strings library

Algorithms

Numerics

Input/output support

Localization support

Thread support (C11)

Atomic operations (C11)

 

C language

General topics
Preprocessor
Comments
Keywords
Escape sequences
History of C
Flow control
Conditional execution statements
if statement	switch statement
Iteration statements
for loop	while loop do-while loop
Jump statements
continue statement break statement	goto statement return statement
Functions
function declaration
inline specifier
Types
fundamental types pointer types compound types enumeration types	union types function types
Specifiers
cv specifiers
storage-class specifiers
alignas specifier (C99)
function specifiers (C99)
Literals
integer literals character literals floating-point literals	string literals boolean literals(C99)
Expressions
order of evaluation
operators
operator precedence
alternative operators
Utilities
typedef declaration
attributes (C99)
casts
Miscellaneous
Inline assembly

 

Every C program contains the definition (not the prototype) of a function called main, which is the designated start of the program.

int main (void) { body }	(1)
int main (int argc, char *argv[]) { body }	(2)
int main (int argc, char *argv[] , other_parameters ) { body }	(3)
/* another implementation-defined signature */	(4)

Parameters

argc	-	Non-negative value representing the number of arguments passed to the program from the environment in which the program is run.
argv	-	Pointer to an array of pointers to null-terminated multibyte strings that represent the arguments passed to the program from the execution environment (argv[0] through argv[argc-1]). The value of argv[argc] is guaranteed to be ​0​.
body	-	The body of the main function
other_parameters	-	Implementations may allow additional forms of the main function. A very common extension is passing a third argument of type char*[] pointing at an array of pointers to the execution environment variables.

The names argc and argv are arbitrary, as well as the representation of the types of the parameters: int main(int ac, char** av) is equally valid.

Return value

If the return statement is used, the return value is used as the argument to the implicit call to exit() (see below for details). The values zero and EXIT_SUCCESS indicate successful termination, the value EXIT_FAILURE indicates unsuccessful termination.

Explanation

The main function is called at program startup, after all objects with static storage duration are initialized. It is the designated entry point to a program that is executed in hosted environment (that is, with an operating system). The name and type of the entry point to any freestanding program (boot loaders, OS kernels, etc) are implementation-defined.

The parameters of the two-parameter form of the main function allow arbitrary multibyte character strings to be passed from the execution environment (these are typically known as command line arguments). The pointers argv[1] .. argv[argc-1] point at the first characters in each of these strings. argv[0] is the pointer to the initial character of a null-terminated multibyte strings that represents the name used to invoke the program itself (or, if this is not supported by the execution environment, argv[0][0] is guaranteed to be zero).

If the execution environment cannot distinguish between uppercase and lowercase letters, the command line arguments are converted to lower case.

The strings are modifiable, and any modifications made persist until program termination, although these modifications do not propagate back to the execution environment: they can be used, for example, with strtok.

The size of the array pointed to by argv is at least argc+1, and the last element, argv[argc], is guaranteed to be a null pointer.

The main function has several special properties:

1) A prototype for this function cannot be supplied by the program

2) If the return type of the main function is compatible to int, then the return from the initial call to main (but not the return from any subsequent, recursive, call) is equivalent to executing the exit function, with the value that the main function is returning passed as the argument (which then calls the functions registered with atexit, flushes and closes all streams, and deletes the files created with tmpfile, and returns control to the execution environment).

3) If the return type of the main function is not compatible with int (e.g. void main(void)), the value returned to the execution environment is unspecified

4) The body of the main function does not need to contain the return statement: if control reaches the end of main without encountering a return statement, the effect is that of executing return 0;.

Example

Demonstrates how to inform a program about where to find its input and where to write its results.

Invocation: ./a.out indatafile outdatafile

Run this code

#include <stdio.h>
 
int main(int argc, char *argv[])
{
    printf("argc = %d\n", argc);
    int ndx = 0;
    while (ndx < argc)
    {
          printf("argv[%d] --> %s\n", ndx,argv[ndx]);
          ++ndx;
    }
    printf("argv[argc] = %s\n", argv[argc]);
    return 0;
}

Possible output:

argc = 3
argv[0] --> ./a.out
argv[1] --> indatafile
argv[2] --> outdatafile
argv[argc] = (null)

See also

C++ documentation for main function