Scope

In programming, we can imagine our code being split into regions, sometimes referred to as scopes.

When we declare a variable in one region or scope, it may not necessarily be accessible to other scopes.

We have thus far been declaring our variables at the top of our files, outside of any function body. This scope is sometimes referred to as the global scope, also known as the file scope.

This is because, as we've seen, we've been able to freely access these variables anywhere within our file:

1#include <iostream>
2using namespace std;
3
4int x{42};
5
6void Log(){ cout << "x is " << x; }
7
8int main(){
9  Log();
10  cout << "\nit's definitely " << x;
11}

1x is 42
2it's definitely 42

But this is not the only place we can declare variables. For example, we can also create variables within the scope of a function, by placing it between the { and } of the function's body.

Below, we've moved our x variable into the scope of our Log function. As a result, it is no longer in the global scope, and is therefore no longer accessible by our main function.

As such, our code throws a compilation error when main attempts to find x:

1#include <iostream>
2using namespace std;
3
4void Log(){
5  int x{42};
6  cout << "x is " << x;
7}
8
9int main(){
10  Log();
11  cout << "\nit's definitely " << x;
12}

1error: 'x': undeclared identifier

Block scopes are created when we have a pair of curly braces {} in our code. For example, function bodies create a block scope, as we've seen above.

This concept isn't limited to function bodies - for example, if and else statements can also create a block scope. Let's see an example:

1#include <iostream>
2using namespace std;
3
4int main() {
5  bool shouldLog{true};
6  if (shouldLog) {
7    string Message{"Hello World"};
8  }
9  cout << Message;
10}

1error: `Message`: undeclared identifier

In this code, the variable Message is declared within the if statement's block. Consequently, Message only exists within this block and is inaccessible outside of it.

When we try to use Message outside of its block (here, in the cout statement), the compiler throws an error. This is because Message is not recognized outside its defining block.

Block scopes do not need to be associated with functions or if statements - we can open a set of curly braces any time we want, thereby creating a new scope.

It's somewhat uncommon to do this, but it highlights the key point:

1#include <iostream>
2using namespace std;
3
4int main() {
5  {
6    string Message{"Hello World"};
7  }
8  cout << Message;
9}

1error: `Message`: undeclared identifier

In C++, the scope access rules govern how different parts of a program can access variables.

The key rule is: a scope can access variables from its parent scopes, but not from its child scopes. The previous errors were all caused by code in a scope trying to access a variable in a nested, or child scope.

Previously, we've been writing code in function scopes that access variables in parent scopes (typically, the global scope). As we've seen, that has been successful:

1#include <iostream>
2using namespace std;
3string Message{"Hello World"};
4
5int main(){
6  // Accessing variable in parent scope
7  cout << Message; 
8}

1Hello World

Below, we show another variation of a child scope successfully accessing a variable in a parent scope:

1#include <iostream>
2using namespace std;
3
4int main(){
5  bool shouldLog{true};
6  string Message{"Hello World"};
7  if (shouldLog) {
8    // Accessing variable in parent scope
9    cout << Message;
10  }
11}

1Hello World

Here, Message is declared in the main function's scope. The if statement within main represents a child scope, nested within the main function's scope.

As such, variables declared in main (parent scope) can be accessed in the if statement (child scope).

1int GetInt() {
2  int x{1};
3  { x++; }
4  return x;
5}

1int GetInt() {
2  {
3    int x{1};
4    x++;
5  }
6  return x;
7}

Shadowing or name hiding occurs when multiple variables with the same name are accessible at once. This is the result of a variable in an inner scope using a name of a variable in one of its parent scopes.

The variable in the inner scope "shadows" the variable in the outer scope, making the outer variable inaccessible within the inner scope. Here's an example to demonstrate this concept:

1#include <iostream>
2using namespace std;
3
4int main(){
5  int x{1};
6  {
7    // This 'x' shadows the outer 'x'
8    int x{2};
9    cout << "Inner x: " << x; // Outputs 2
10  }
11  cout << "\nOuter x: " << x; // Outputs 1
12}

1Inner x: 2
2Outer x: 1

In this example, there are two variables named x. The x inside the block is separate and shadows the x declared in the main function.

Within the block, any reference to x refers to the inner x (with value 2), not the outer x (with value 1). When the block ends, the inner x goes out of scope, and the outer x becomes accessible again.

Shadowing is typically something we want to avoid, as it can lead to confusion and bugs. However, it's still important to understand what's going on here, so we can ensure we're accessing the correct variables.

1int GetInt() {
2  int x{1};
3  {
4    int x{2};
5  }
6  return x;
7}

In this lesson on scope in C++, you've learned several key concepts:

• Global/File Scope: Variables declared outside any function have global scope and can be accessed anywhere within the file.
• Block Scope: Variables declared within a set of {} are only accessible within those braces.
• Scope Access Rules: A scope can access variables from its parent scopes but not from its child scopes.
• Shadowed Variables/Name Hiding: When two variables with the same name exist in different scopes, the one in the inner scope shadows the one in the outer scope.