Static and Dynamic Scoping

The scope of a variable refers to the region of a program where that variable can be accessed. Scoping helps keep variables used in different parts of a program separate from one another, even if they have the same name. This is important because programmers often reuse common variable names such as i, x, or count in different parts of a program.

Scoping is generally divided into two types:

1. Static Scoping
2. Dynamic Scoping

Static Scoping: 

Also known as lexical scoping, determines the scope of a variable based on the structure of the program code. In this approach, the binding of a variable can be determined by examining the program text, regardless of how the program executes at runtime. The compiler searches for a variable in the following order: Current block, Enclosing blocks, Global scope. Most modern programming languages such as C, C++, Java, and Python use static scoping. Because the scope is known at compile time, it makes programs easier to understand, debug, and optimize.

// A C program to demonstrate static scoping.
#include<stdio.h>
int x = 10;

// Called by g()
int f()
{
   return x;
}

// g() has its own variable
// named as x and calls f()
int g()
{
   int x = 20;
   return f();
}

int main()
{
  printf("%d", g());
  printf("\n");
  return 0;
}

Output : 

10

Dynamic Scoping:

The value of a variable is determined by the most recent function call in the program’s call stack. Instead of following the program structure, the runtime system searches for variable definitions in the chain of active function calls. The search order is: Current function, Calling function, Functions higher in the call stack. Rarely used in modern programming languages.

// Since dynamic scoping is very uncommon in 
// the familiar languages, we consider the 
// following pseudo code as our example. It
// prints 20 in a language that uses dynamic
// scoping.   

int x = 10;

// Called by g()
int f()
{
   return x;
}

// g() has its own variable
// named as x and calls f()
int g()
{
   int x = 20;
   return f();
}

main()
{
  printf(g());
}

 
Output in a language that uses Dynamic Scoping : 

20

Static Vs Dynamic Scoping