Difference between static, auto, global and local variable in the context of c and c++

There are two separate concepts here:

• scope, which determines where a name can be accessed, and
• storage duration, which determines when a variable is created and destroyed.

Local variables (pedantically, variables with block scope) are only accessible within the block of code in which they are declared:

void f() {    int i;    i = 1; // OK: in scope}void g() {    i = 2; // Error: not in scope}

Global variables (pedantically, variables with file scope (in C) or namespace scope (in C++)) are accessible at any point after their declaration:

int i;void f() {    i = 1; // OK: in scope}void g() {    i = 2; // OK: still in scope}

(In C++, the situation is more complicated since namespaces can be closed and reopened, and scopes other than the current one can be accessed, and names can also have class scope. But that's getting very off-topic.)

Automatic variables (pedantically, variables with automatic storage duration) are local variables whose lifetime ends when execution leaves their scope, and are recreated when the scope is reentered.

for (int i = 0; i < 5; ++i) {    int n = 0;    printf("%d ", ++n);  // prints 1 1 1 1 1  - the previous value is lost}

Static variables (pedantically, variables with static storage duration) have a lifetime that lasts until the end of the program. If they are local variables, then their value persists when execution leaves their scope.

for (int i = 0; i < 5; ++i) {    static int n = 0;    printf("%d ", ++n);  // prints 1 2 3 4 5  - the value persists}

Note that the static keyword has various meanings apart from static storage duration. On a global variable or function, it gives it internal linkage so that it's not accessible from other translation units; on a C++ class member, it means there's one instance per class rather than one per object. Also, in C++ the auto keyword no longer means automatic storage duration; it now means automatic type, deduced from the variable's initialiser.

First of all i say that you should google this as it is defined in detail in many places

Local
These variables only exist inside the specific function that creates them. They are unknown to other functions and to the main program. As such, they are normally implemented using a stack. Local variables cease to exist once the function that created them is completed. They are recreated each time a function is executed or called.

Global
These variables can be accessed (ie known) by any function comprising the program. They are implemented by associating memory locations with variable names. They do not get recreated if the function is recalled.

/* Demonstrating Global variables  */    #include <stdio.h>    int add_numbers( void );                /* ANSI function prototype */    /* These are global variables and can be accessed by functions from this point on */    int  value1, value2, value3;    int add_numbers( void )    {        auto int result;        result = value1 + value2 + value3;        return result;    }    main()    {        auto int result;        value1 = 10;        value2 = 20;        value3 = 30;                result = add_numbers();        printf("The sum of %d + %d + %d is %d\n",            value1, value2, value3, final_result);    }    Sample Program Output    The sum of 10 + 20 + 30 is 60

The scope of global variables can be restricted by carefully placing the declaration. They are visible from the declaration until the end of the current source file.

#include <stdio.h>void no_access( void ); /* ANSI function prototype */void all_access( void );static int n2;      /* n2 is known from this point onwards */void no_access( void ){    n1 = 10;        /* illegal, n1 not yet known */    n2 = 5;         /* valid */}static int n1;      /* n1 is known from this point onwards */void all_access( void ){    n1 = 10;        /* valid */    n2 = 3;         /* valid */}

Static:
Static object is an object that persists from the time it's constructed until the end of the program. So, stack and heap objects are excluded. But global objects, objects at namespace scope, objects declared static inside classes/functions, and objects declared at file scope are included in static objects. Static objects are destroyed when the program stops running.
I suggest you to see this tutorial list

AUTO:
C, C++

(Called automatic variables.)

All variables declared within a block of code are automatic by default, but this can be made explicit with the auto keyword.[note 1] An uninitialized automatic variable has an undefined value until it is assigned a valid value of its type.[1]

Using the storage class register instead of auto is a hint to the compiler to cache the variable in a processor register. Other than not allowing the referencing operator (&) to be used on the variable or any of its subcomponents, the compiler is free to ignore the hint.

In C++, the constructor of automatic variables is called when the execution reaches the place of declaration. The destructor is called when it reaches the end of the given program block (program blocks are surrounded by curly brackets). This feature is often used to manage resource allocation and deallocation, like opening and then automatically closing files or freeing up memory.SEE WIKIPEDIA

Difference is static variables are those variables: which allows a value to be retained from one call of the function to another. But in case of local variables the scope is till the block/ function lifetime.

For Example:

#include <stdio.h>void func() {    static int x = 0; // x is initialized only once across three calls of func()    printf("%d\n", x); // outputs the value of x    x = x + 1;}int main(int argc, char * const argv[]) {    func(); // prints 0    func(); // prints 1    func(); // prints 2    return 0;}