What is the difference between static global and local global variable?

Answer 1

First, lets speak about the scope of a variable. The scope of a variable is the section of the application that can see and manipulate that variable. If the variable is declared in a procedure when that procedure is called, only that procedure can use that variable. Hence that variable is considered "Local".

Now Static. Static variables are variables that are created with the static key word as in:- function ab(var1 as integer)as integer static iTotal as integer itotal =iTotal + var1 (rest of ccode goes here) end function

Now when this function is called the first time, iTotal will be assigned the value of var1. The next time the function is called, iTotal will retain the previous value and the new value of var1 will be added to it. Hope this helps. (theTeacha)

Static variables life time is not under any scope.It initializes only one time from creation to delete.let me explain by a pgm.

void main()

{

int a=1;

static s=1;

int k=0;

for(k=0;k<1;k++)

{

i++;

s++;

main();

}

printf("%d is i",&i);

printf(%d is S",&s);

getch();

}

Output will be

2 is i

3 is s

It Shows that local variable initialize every time the function call.But Static variable initializes only once

<><><>

For a variable, static means it keeps its value even when the enclosing code is not active--out of scope. A static variable is assigned to a fixed memory location when the program runs, so it is possible to examine a static variable at any time the program is active, even when the function where the var is declared is not active. A local variable is dynamically allocated storage space when a function is called, and its storage is given up when the function ends, so it only exists while the function is executing.

For a function, static declaration means it can only be called from functions in the same file (in C).

Answer 2

From Java point of view, static global class members are shared among all class instances and can be accessed from any class member [Methods]. While local global [attributes] can be accessed from any class member [method] but not shared with other class instances The global variable can be shared across multiple files. But the global static variable cannot be shared across multiple files. Hence if you want the variable should be modified in some other file, you can make it a global variable and if you want a global variable only in the file you are declaring and not to shared across, you make it static global. the following code snippet should be useful. //ext2.c int a=10; static int s_b=89; //ext.c extern int a; extern int s_b; int main() { printf("a = %d\n",a); printf("static b = %d\n",s_b); return 0; } then build the exe with ext.o and ext2.o and try running.. you will encounter an error like this "./ext.o(.text+0x20): undefined reference to `s_b'" Regards, ~Naren

Answer 3

Static global variable has scope only in the file in which it is declared. it can't be accessed in any other file but its value remains intact if code is running in some other file means lifetime is in complete programme while static local variable has scope in that function in which it is declared means it can't be used in other functions in the same file also, means scope is limited to the function in which it is declared while its life time is also through out the programme.

Answer 4

when you declare as static int default value will be initialized to zero .and its values persits during the program and local to the black where as global declaration you can access any where in the program initialised to zero and it values will not persits

Answer 5

A local variable is a variable that is declared inside a code block. A code block typically starts with an opening brace and ends with a closing brace:

{

// code block here

}

The local variable is scoped to that block in which it is declared and will fall from scope when that code block ends.

A global variable is a variable that is not defined inside a code block. A global variable is scoped to the file or translation unit in which it is declared. Although we tend to think of a global as being globally accessible to all code, this is not the case at all. It is only globally accessible to code within the same translation unit.

If we want other translation units to be able access a global variable, then those translation units must redeclare the global with external linkage. This is never a good idea. Code that operates upon a variable should remain as closely-coupled to that variable as possible. This makes code easier to both read and maintain. If external code gains access to a variable, it becomes that much harder to determine when, where and why a variable's value is changing. Since there's no physical way to prevent an external translation unit from declaring external linkage to a global variable, the only solution is to avoid using global variables in the first place.

Object oriented programming provides the best solution by allowing the programmer to encapsulate the variable and the functions that specifically operate upon it as a single entity; a class. The variable should be declared a private static member of the class and the operations as static methods (public or private, depending on whether the methods should be accessible from outside of the class or not). Where external linkage is required, the class can grant friend access to the code that specifically requires it, rather than allowing the code to grant itself external linkage as it can with a global variable.

Global constants are less of a problem since a constant cannot change value. Thus there's no reason to prevent external-linkage to a constant. But with global variables, there's rarely a good reason to allow external-linkage. If a variable is truly global, then there's no reason not to use one, but there are actually very few good reasons where a truly global variable needs to exist. A trace log is a good example, as are standard input and output devices.

Answer 6

A static variable has a value that persists throughout the entire execution of the program. A global variable is declared at file scope, i.e. outside of any functions, and therefore has visibility (scope) from all functions, including functions in other compilation units that are linked together. A global variable also has value that persists throughout the entire execution of the program.

Do not confuse this with static global, which means that visibility is limited to function in the same compilation unit.

Answer 7

When you say static variable, do you mean local static variable or global static variable?

In C, the difference between global static variables and global variables is that static in this case means that the variable can be used only in the module (.c file) that it is declared.

The difference between a local static variable and a global variable is the scope: the local variable can be used only inside the function that declares it. So you can have 2 local static variables in the same file with the same name but in different functions and they will be 2 different variables.

Answer 8

static variable is available to the module where it is defined. Global variable is available through out the pgm

Answer 9

Their scope.