Introductory Programming Lecture Notes: Scope

Scoping rules

What is scope?

The scope of a variable or a parameter is simply the section of the program where you are allowed to access that particular variable or parameter

#include <cstdio>

const float Pi = 3.14;

float calc_area(float radius);

int main()
{
   int x, y;
   ...
}

float calc_area(float radius)
{
   float area;
   ...
}

Pi can be used throughout the program
x and y can be used only in main
radius and area can be used only in calc_area

Scope of variables and parameters

Variables and parameters can only be accessed within the routine (function or main) in which they are declared
Their scope is said to be local to that function
Variables (or parameters) in different functions can have the same name, but they are still different variables - they represent different storage areas in memory.
```
void function_one(int x)
{
   float y;
}

void function_two(char x)
{
   int y;
}
```
In most programming languages (including C++) you cannot declare two different variables in the same scope:
- You can have a global variable and a local variable with the same name ... the value accessed will be the local one. For example, the following program will output 2, as the variable accessed is the one local to main:
```
#include <cstdio>

int X = 1;

int main()
{
   int X = 2;
   
   printf("%d\n", X);
}
```
- You cannot have two local variables with the same name
- You cannot have a local variable with the same name as a parameter (in the same routine)
Just to reduce confusion when reading your program, you should be careful about using the same variable name for very different things in different functions
It is possible to declare variables globally, but generally leads to very poor programming style.
A profusion of global variables increases the likelihood of mistakes in two major ways:
- updating a global variable in many different routines makes it difficult to assess the possible impact of modifications to any of those routines, and makes it difficult to verify the program's correctness
- it increases the chances of altering the wrong variable (thinking you're accessing a global variable, rather than the local one with the same name)
As a general rule (and as a requirement for assignments in this course for the rest of the semester) always declare your variables either inside the main function or inside one of your own functions

Scope of types and const

User defined types (such as Boolean) and constant declarations are visible throughout the entire program

These are said to be global definitions

#include <cstdio>

const float Pi = 3.14;
const int TRUE = 1;
const int FALSE = 0;
typedef int Boolean;

float calc_area();

int main()
{
  ...
}

float calc_area()
{
  ...
}