Difference Between Static, Auto, Global and Local Variable in the Context of C and C++

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.

difference between global and static variable in c

Both variables are "global". They both have the static storage duration. The difference is that the first has external linkage and the second has internal linkage that is it is invisible outside the compilation unit where it is declared. If the declaration of a variable with internal linkage is included in several compilation units then each of them has its own unique variable with this name.

From the C Standard (6.2.2 Linkages of identifiers)

2 In the set of translation units and libraries that constitutes an
entire program, each declaration of a particular identifier with
external linkage denotes the same object or function. Within one
translation unit, each declaration of an identifier with internal
linkage denotes the same object or function. Each declaration of an
identifier with no linkage denotes a unique entity.

and

3 If the declaration of a file scope identifier for an object or a
function contains the storage class specifier static, the identifier
has internal linkage.

Using a variable with internal linkage hides implementation and prevents a conflict with a variable with the same name with external linkage.

Static vs global

i has internal linkage so you can't use the name i in other source files (strictly translation units) to refer to the same object.

j has external linkage so you can use j to refer to this object if you declare it extern in another translation unit.

Where in memory are my variables stored in C?

You got some of these right, but whoever wrote the questions tricked you on at least one question:

global variables -------> data (correct)
static variables -------> data (correct)
constant data types -----> code and/or data. Consider string literals for a situation when a constant itself would be stored in the data segment, and references to it would be embedded in the code
local variables(declared and defined in functions) --------> stack (correct)
variables declared and defined in main function -----> ~~heap~~ also stack (the teacher was trying to trick you)
pointers(ex: char *arr, int *arr) -------> ~~heap~~ data or stack, depending on the context. C lets you declare a global or a static pointer, in which case the pointer itself would end up in the data segment.
dynamically allocated space(using malloc, calloc, realloc) --------> ~~stack~~ heap

It is worth mentioning that "stack" is officially called "automatic storage class".

What is the Static Global Variable Purpose?

The term "maintaining last value" causing the confusion for you. The term "maintaining last value" would be used on the context of function local variable vs function static variable. Because variable declared within a function got stored in stack, and on exiting the function will be cleared the stack used by that function which leaves the variable dead.

But creating a function local variable with static is creating a memory in RAM(and not in stack), which allows the memory to hold even after exit of the function. Even the global variables and file static variables are stored in RAM thereby retaining its value forever.

So, for your question any variable stored in RAM will "maintain its last value" irrespective of its keyword static. But the static limits its scope of its usage, ie., if declared in the file scope then it can be used(accessed) within the file, if declared in the function scope then its scope limits within the function alone.

Example of a static vs automatic variable in assembly

Just try it

void more_fun ( int );
void fun0 ( void )
{
    for (int i = 0; i < 500; ++i) {
        static int n = 0;
        more_fun(++n);
    }
}
void fun1 ( void )
{
    for (int i = 0; i < 500; ++i) {
        int n = 0;
        more_fun( ++n);
    }
}


Disassembly of section .text:

00000000 <fun0>:
   0:   e92d4070    push    {r4, r5, r6, lr}
   4:   e3a04f7d    mov r4, #500    ; 0x1f4
   8:   e59f501c    ldr r5, [pc, #28]   ; 2c <fun0+0x2c>
   c:   e5953000    ldr r3, [r5]
  10:   e2833001    add r3, r3, #1
  14:   e1a00003    mov r0, r3
  18:   e5853000    str r3, [r5]
  1c:   ebfffffe    bl  0 <more_fun>
  20:   e2544001    subs    r4, r4, #1
  24:   1afffff8    bne c <fun0+0xc>
  28:   e8bd8070    pop {r4, r5, r6, pc}
  2c:   00000000

00000030 <fun1>:
  30:   e92d4010    push    {r4, lr}
  34:   e3a04f7d    mov r4, #500    ; 0x1f4
  38:   e3a00001    mov r0, #1
  3c:   ebfffffe    bl  0 <more_fun>
  40:   e2544001    subs    r4, r4, #1
  44:   1afffffb    bne 38 <fun1+0x8>
  48:   e8bd8010    pop {r4, pc}

Disassembly of section .bss:

00000000 <n.4158>:
   0:   00000000    andeq   r0, r0, r0

I like to think of static locals as local globals. They sit in .bss or .data just like globals. But from a C perspective they can only be accessed within the function/context that they were created in.

I local variable has no need for long term storage, so it is "created" and destroyed within that fuction. If we were to not optimize you would see that
some stack space is allocated.

00000064 <fun1>:
  64:   e92d4800    push    {fp, lr}
  68:   e28db004    add fp, sp, #4
  6c:   e24dd008    sub sp, sp, #8
  70:   e3a03000    mov r3, #0
  74:   e50b300c    str r3, [fp, #-12]
  78:   ea000009    b   a4 <fun1+0x40>
  7c:   e3a03000    mov r3, #0
  80:   e50b3008    str r3, [fp, #-8]
  84:   e51b3008    ldr r3, [fp, #-8]
  88:   e2833001    add r3, r3, #1
  8c:   e50b3008    str r3, [fp, #-8]
  90:   e51b0008    ldr r0, [fp, #-8]
  94:   ebfffffe    bl  0 <more_fun>
  98:   e51b300c    ldr r3, [fp, #-12]
  9c:   e2833001    add r3, r3, #1
  a0:   e50b300c    str r3, [fp, #-12]
  a4:   e51b300c    ldr r3, [fp, #-12]
  a8:   e3530f7d    cmp r3, #500    ; 0x1f4
  ac:   bafffff2    blt 7c <fun1+0x18>
  b0:   e1a00000    nop         ; (mov r0, r0)
  b4:   e24bd004    sub sp, fp, #4
  b8:   e8bd8800    pop {fp, pc}

But optimized for fun1 the local variable is kept in a register, faster than keeping on the stack, in this solution they save the upstream value held in r4 so
that r4 can be used to hold n within this function, when the function returns there is no more need for n per the rules of the language.

For the static local, per the rules of the language that value remains static
outside the function and can be accessed within. Because it is initialized to 0 it lives in .bss not .data (gcc, and many others). In the code above the linker
will fill this value

  2c:   00000000

in with the address to this

00000000 <n.4158>:
   0:   00000000    andeq   r0, r0, r0

IMO one could argue the implementation didnt need to treat it like a volatile and
sample and save n every loop. Could have basically implemented it like the second
function, but sampled up front from memory and saved it in the end. Either way
you can see the difference in an implementation of the high level code. The non-static local only lives within the function and then its storage anc contents
are essentially gone.

Where are the local, global, static, auto, register, extern, const, volatile variables are stored?

local variables can be stored either on the stack or in a data segment depending on whether they are auto or static. (if neither auto or static is explicitly specified, auto is assumed)
global variables are stored in a data segment (unless the compiler can optimize them away, see const) and have visibility from the point of declaration to the end of the compilation unit.
static variables are stored in a data segment (again, unless the compiler can optimize them away) and have visibility from the point of declaration to the end of the enclosing scope. Global variables which are not static are also visible in other compilation units (see extern).
auto variables are always local and are stored on the stack.
the register modifier tells the compiler to do its best to keep the variable in a register if at all possible. Otherwise it is stored on the stack.
extern variables are stored in the data segment. The extern modifier tells the compiler that a different compilation unit is actually declaring the variable, so don't create another instance of it or there will be a name collision at link time.
const variables can be stored either on the stack or a readonly data segment depending on whether they are auto or static. However, if the compiler can determine that they cannot be referenced from a different compilation unit, or that your code is not using the address of the const variable, it is free to optimize it away (each reference can be replaced by the constant value). In that case it's not stored anywhere.
the volatile modifier tells the compiler that the value of a variable may change at anytime from external influences (usually hardware) so it should not try to optimize away any reloads from memory into a register when that variable is referenced. This implies static storage.

BTW all this applies to C & C++ as well as Objective-C.

Where are static variables stored in C and C++?

Where your statics go depends on whether they are zero-initialized. zero-initialized static data goes in .BSS (Block Started by Symbol), non-zero-initialized data goes in .DATA

What does static mean in C?

A static variable inside a function keeps its value between invocations.
A static global variable or a function is "seen" only in the file it's declared in

(1) is the more foreign topic if you're a newbie, so here's an example:

#include <stdio.h>

void foo()
{
    int a = 10;
    static int sa = 10;

    a += 5;
    sa += 5;

    printf("a = %d, sa = %d\n", a, sa);
}


int main()
{
    int i;

    for (i = 0; i < 10; ++i)
        foo();
}

This prints:

a = 15, sa = 15
a = 15, sa = 20
a = 15, sa = 25
a = 15, sa = 30
a = 15, sa = 35
a = 15, sa = 40
a = 15, sa = 45
a = 15, sa = 50
a = 15, sa = 55
a = 15, sa = 60

This is useful for cases where a function needs to keep some state between invocations, and you don't want to use global variables. Beware, however, this feature should be used very sparingly - it makes your code not thread-safe and harder to understand.

(2) Is used widely as an "access control" feature. If you have a .c file implementing some functionality, it usually exposes only a few "public" functions to users. The rest of its functions should be made static, so that the user won't be able to access them. This is encapsulation, a good practice.

Quoting Wikipedia:

In the C programming language, static
is used with global variables and
functions to set their scope to the
containing file. In local variables,
static is used to store the variable
in the statically allocated memory
instead of the automatically allocated
memory. While the language does not
dictate the implementation of either
type of memory, statically allocated
memory is typically reserved in data
segment of the program at compile
time, while the automatically
allocated memory is normally
implemented as a transient call stack.

And to answer your second question, it's not like in C#.

In C++, however, static is also used to define class attributes (shared between all objects of the same class) and methods. In C there are no classes, so this feature is irrelevant.

Difference Between Static, Auto, Global and Local Variable in the Context of C and C++