Scope and Storage Classes in C++

In this lesson: Scope and storage classes in C++ — local, global, static, extern, thread_local — with examples. In Hindi & English.

Scope and storage — two different questions

Every variable answers two questions:

• Scope: *where* in the code can I use this name?
• Storage duration (lifetime): *when* is the variable created and destroyed?

Beginners often mix these up. A static variable inside a function, for example, can only be *used* inside that function (small scope) but *exists* for the whole run of the program (long lifetime). Storage class specifiers — static, extern, thread_local, mutable — control lifetime and linkage.

Types of scope

#include <iostream>
int total = 100;               // global

int main() {
    int total = 5;             // local, hides the global
    {
        int bonus = 2;         // block scope
        std::cout << total + bonus << "\n";   // 7
    }
    // std::cout << bonus;     // error: bonus not in scope here
    std::cout << ::total << "\n";             // 100 — global via ::
    return 0;
}

When a local name hides a global one, the scope resolution operator ::name reaches the global. Hiding names like this is legal but confusing — better to choose different names.

Automatic storage (the default)

Local variables without a specifier have automatic storage: they are created when execution reaches the declaration and destroyed when the block ends. Each function call gets fresh copies. Uninitialised automatic variables contain garbage, so always initialise them.

static local variables

A static local variable is initialised once and keeps its value between calls.

#include <iostream>

void markAttendance() {
    static int count = 0;      // created once, lives until program ends
    int calls = 0;             // automatic: recreated every call
    count++;
    calls++;
    std::cout << "count = " << count << ", calls = " << calls << "\n";
}

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

count remembers its value; calls starts at 0 every time.

static globals and static class members

• A static global variable or function is visible only in its own .cpp file (internal linkage). In modern C++ an anonymous namespace does the same job.
• A static class member belongs to the class, not to each object — one shared copy. See static members.

extern: sharing a global across files

// config.h
extern int maxStudents;        // declaration only — no memory yet

// config.cpp
int maxStudents = 40;          // the one definition

// main.cpp
#include "config.h"
#include <iostream>
int main() {
    std::cout << maxStudents << "\n";   // 40
}

Every file that includes config.h can use maxStudents, but only config.cpp defines it. Defining it in the header instead would cause "multiple definition" errors.

thread_local, mutable, register and auto

• thread_local (C++11): each thread gets its own copy of the variable, living as long as the thread.
• mutable: lets a data member be changed even inside a const member function — used for caches and counters.
• register: once a hint to keep a variable in a CPU register; deprecated in C++11 and removed in C++17. Compilers optimise this themselves.
• auto: in old C/C++ meant "automatic storage". Since C++11 it means "deduce the type": auto x = 3.5; makes x a double.

class Report {
    mutable int views = 0;
public:
    void show() const { views++; /* allowed because mutable */ }
};

Storage classes compared

Common mistakes

• Returning a pointer or reference to a local (automatic) variable — it is destroyed when the function ends.
• Expecting a non-static local to remember its value between calls.
• Defining (not just declaring) a global in a header included by many files.
• Overusing global variables, which makes programs hard to test and debug.
• Writing register int i; in modern C++ — it is an error in C++17.

Summary

• Scope = where a name is visible; lifetime = how long the variable exists.
• Local variables are automatic: created and destroyed with their block.
• static locals keep their value between calls; static globals are file-private.
• extern declares a global defined in another file.
• register is gone; auto now means type deduction; mutable and thread_local are special cases.

Related: functions, static members, namespaces.