Scope of Variables within Functions in C

Introduction

accessible only within the main() function. No other function can directly access that variable. Also, it will be destroyed after the completion of the function. So, the lifetime of a variable is until the main() function completes its execution. Consider the following example:

#include <stdio.h>

void fun(void) {
    printf("%d", x);
}

int main() {
    int x = 10;
    fun();
    return 0;
}

Output:

Error. Undeclared identifier x.

Explanation:

The variable x is accessible only within the main() function as it is declared within the main() function. No other function can access it directly. We tried doing the same in the above function, but unfortunately we got an error 😕

The concept of scope of a variable plays an important role in understanding how variables are accessed and managed within functions. After understanding this concept through this tutorial, you can easily spot the area of visibility of a variable. Not only this, you can tell how long a variable will survive. You will obtain all these superpowers by the end of the tutorial, so let’s dive in.

Local Scope

Variables with local scope are called local variables. They are defined within a function or a block and due to this reason, the area of visibility is within the function or a block in which they are defined, and they survive until the function or a block completes its execution. 

• Visibility:  within the function or a block. 
• Lifetime:  till the function or a block completes its execution. 

Consider the following code:

#include <stdio.h>

void fun(void) {
    int x = 10;
    printf("%d", x);
}

int main() {
    fun();
    return 0;
}

Output:

10

Explanation:

The variable x is defined within the function fun(), so it is local to fun(). This means the variable x’s is accessible only within the fun() function and it will be destroyed after the execution of the function is done.

Global Scope

Variables defined in the global scope are called global variables. They are typically defined outside any function and at the top of the program (after the header files declaration and function prototypes). 

• Visibility:  accessible to all the functions of the program.
• Lifetime:  exist for the entire duration of the program’s execution. 

Consider the following code to better understand this concept:

#include <stdio.h>

int globalVar = 10;

void fun(void) {
    globalVar *= 10;
}

int main() {
    fun();
    printf("%d", globalVar);
    return 0;
}

Output:

100

Explanation:

globalVar is the global variable defined in the above program. We are accessing the variable within the fun() and the main() function. This clearly shows that the globalVar is accessible throughout the program. The function fun() is updating the globalVar making it equal to 100. Then, within the main() function, the value of the globalVar is displayed using the printf() function. 

There are a few considerations to keep in mind before declaring and using these variables:

• Global variables are accessible to all the functions and hence, can be modified by any. This may lead to potential bugs which are difficult to spot. So, try to avoid declaring these variables whenever possible until it is super necessary for your application to work. 
• Global variables cause “name conflicts” as they may conflict with the local variables of the functions. Out of local and global variables, local variables always win and hence, if the programmer wants to update the global variable, they may not be able to do so if the variable with the same name is declared within the function. So, be careful.

Static Variables

Static variables can either be local or global, but they retain their values either within the function calls or the entire file depending on where they are defined. 

• Static local variables: retain their values within function calls. 
• Static global variables: retain their values throughout the program but are not accessible outside the program file in which they are defined. 

Consider the following example of static local variable:

#include <stdio.h>

void fun(void) {
    static var = 5;
    var++;
    printf("%d ", var);
}

int main() {
    fun();
    fun();
    fun();
    return 0;
}

Output:

6 7 8

Explanation:

The variable var is declared as static within the function fun() and hence, it has the capability to retain its value. As it is defined with the function fun(), it’s visibility is within this function only. If we try to access it within the main() function, we would not be able to do so. 

Now, consider the following example of static global variable:

#include <stdio.h>

static var = 5;

void fun(void) {
    var++;
}

int main() {
    fun();
    fun();
    fun();
    printf("%d", var);
    return 0;
}

Output:

8

Explanation:

The variable is a global static variable, hence it can retain its value and it is visible throughout the program. This is the reason why both the main() and fun() functions can access it and make changes to it.

Function Parameters

Function parameters are a special type of local variables which are declared within a function and receive values from the arguments of the caller.

• Visibility:  within the function in which they are declared. 
• Lifetime: exists only for the duration of the function call.  

Consider the following example:

#include <stdio.h>

void fun(int x) {
    printf("%d", x);
}

int main() {
    int x = 20;
    fun(x);
    return 0;
}

Output:

20

Explanation:

Variable x is declared as a parameter within the function fun() and receives value 20 from the caller within the main() function.

Check Your Understanding

#include <stdio.h>

int x = 10;

void fun() {
    int x = 30;
    printf("%d ", x);
}

int main() {
    printf("%d ", x);
    fun();
    printf("%d", x);
    return 0;
}

Your score is out of

Conclusion

Scope of a variable depends upon the area where the variable is defined. If a variable is defined within a function or a block, its visibility is within that function or the block and the variable is called the local variable. If it is defined outside all the functions and at the top of the program, then the variable is accessible throughout the program and it is called the global variable. Apart from this, in this tutorial we learned how putting static in front of a variable can change its behavior. Also, at last we discussed function parameters which are special types of local variables.