Difference between global and local variables?

Answer 1

The scope or the life span. The life span is from the birth (allocation) to death (deallocation).

The life span of a global variable starts when the application is invoked. It dies when the application terminated. During the execution of the application , this global variable is available to any program unit within that application.

The life span of a local variable, well, only locally. "Local" means a component, a method (subroutine), or even within a bracket ({} or BEGIN-END) of a statement.

Outside of that block of codes, that local variable does not exist, hence cannot be accessed or referenced. Also, the same name of that local variable may be declared again in another local area without conflict, nor memory of the previous one.

For languages similar to C:

for (int i = 0; i < 100; i++)

{

// i can be referenced within { }, and within the for() control itself

}

for (int i = -1; i > -200; i--)

{

// this i is different from the i in the previous for-loop

}

Some computer language would allow you to declare a local variable with the same name as the global one (for example, there are global::X and local::X, but the code only refer as X). Most of the computer language would replace X with local::X at compile time, some would replace it with global::X) Some languages may not have the notion of local variables, everything is global, and some would not have the notion of global variable, but would provide a mean to act like one.

Answer 2

A local variable is defined and declared within a block. It only has scope (visibility) within that block. Unless it is declared static, it only has lifetime within that block.

A global variable is defined and declared at file scope, i.e. outside of any block. It has scope to all blocks within that block. Unless it is declared static, it also has scope to all other modules that are linked to the file. Note that the meaning of static here is entirely different than the meaning of static within a block.

Answer 3

A global variable remains in scope throughout the life-cycle of the program. This exposes the variable to uncontrolled changes from any code that has access to it.

A local variable is scoped within a block of code (a function or statement block) and will fall from scope when the code block falls from scope. Thus only the code block can alter the variable.

A static local variable is a bit like a global in that it exists throughout the program's life-cycle, however it is still a local variable and therefore has limited scope. The only real difference is that the variable retains its value between calls to the code block, whereas a non-static local variable is destroyed when the code block falls from scope.

Answer 4

I'm assuming you're referring to computer programming. A global variable can be accessed by all functions. It is initialized at the beginning of the program and is deleted when the program shuts down. A local variable is isolated in its function. Here's an example in C:

#include <stdio.h>

int other_function();

int global_int = 2; /*This is a global variable that can be accessed by any function in the program.*/

int main( int numArgs, char *argList[] )

{

int local_int = 1; /*This is a local variable. It can only be accessed inside of main(). Once main() ends, the variable is deleted and the data is erased.*/

printf( "Global variable is %i. Local variable is %i.\n", global_int, local_int );

other_function();

return 0;

}

int other_function()

{

printf( "Global variable is %i. The variable "local_int" located in main() can not be accessed. This line of code will return an error %i", global_int, local_int ); /*This line attempts to access local_int, which does not exist because it is available only to the function main()*/

return 0;

}

I hope tat answered your question.

Answer 5

Local variables are allocated on the stack while global variables are allocated in the program's data segment.

A local variable is scoped to the code block in which it is declared. Local variables are created when the scope becomes active and destroyed when the scope ends. Local variables can be scoped to an entire function, a code block within a function or to a class (nonstatic member variable).

A global variable exists for the entire duration the program is running and is accessible from any code. The scope of a global is the translation unit in which it is declared, however any other translation unit can grant itself access to a global variable by declaring that variable as an external variable. Global variables are generally frowned upon since the author of the translation unit has no control over which translation units may grant themselves access, making it difficult to determine when, where and why a global variable is changing value. Global constants are less of a problem since the value cannot change.

Answer 6

The scope (life span) and the accessibility.

Global variables has the longest life span of any variables in other scope (local, temp.). Conceptually it lasts the duration of the application execution.

A global variable should be "globally" accessible. That is, from anywhere in the application, any unit, and any module.

A local variable lives within the scope - locally. The scope starts with the method (procedure, subroutine, function) being invoked and ends with the end of the subroutine, and hence conceptually and normally a local variable should not be globally accessible.

Answer 7

Their scope.