Scope, duration, and linkage Summary

What Are Scope, Duration, and Linkage?

Scope, duration, and linkage are three separate properties that every declaration carries. Scope is about the source code: which regions of text may spell the name. Duration is about the running program: when the object is created and when it is destroyed. Linkage is about the build: whether two declarations of the same spelling refer to one entity or to two unrelated ones.

They get confused with each other because a single keyword often changes two of them at once, and because the most common declarations happen to pair the same answers together. This lesson pulls them apart, then puts them back together as a reference you can return to.

Three Independent Questions

Point at any declaration and ask three questions in order. Each has a small, closed set of answers.

The rest of the lesson works through the answers one question at a time.

Question One: Where May the Name Be Written?

Scope answers a question about text: over which stretch of the file does this name mean anything? It is a compile-time, text-level property: it is decided entirely by where the declaration sits, and the compiler enforces it by refusing to recognise the name anywhere else.

Block (local) scope runs from the point of declaration to the closing brace of the enclosing block, nested blocks included. Three things get block scope:

• local variables
• function parameters
• program-defined types, such as enumerations and classes, declared inside a block

Global scope runs from the point of declaration to the end of the file. Three things get global scope:

• global variables
• functions
• program-defined types declared at global scope or inside a namespace

Because a name in global scope is still limited to one file's worth of text, seeing a name in another file requires a second declaration there. Whether that second declaration refers to the same entity is question three, not question one.

Question Two: How Long Does the Object Live?

A variable's duration determines when it is created and destroyed. Duration is a runtime property, and it is decided by the storage the variable is given rather than by where its name appears.

• Automatic duration: created at the point of definition, destroyed when the enclosing block exits. Local variables and function parameters have automatic duration by default.
• Static duration: created once when the program starts, destroyed when the program ends. Global variables and static local variables have static duration.
• Dynamic duration: created and destroyed on request, at whatever moments the programmer chooses. Dynamically allocated variables have dynamic duration. A later chapter covers how to request and release that storage.

Question Three: Which Declarations Mean the Same Entity?

An identifier's linkage determines whether declarations of that identifier in different scopes refer to the same entity, meaning the same object, function, or reference. Linkage is a link-time property, which is why it is the one that reaches past the boundaries of a single file.

• No linkage: every declaration introduces its own separate entity. Local variables have no linkage, as do program-defined type identifiers declared inside a block. Two functions may each declare a local named total and the two are unrelated variables.
• Internal linkage: declarations of the name inside one translation unit refer to the same entity, and other translation units cannot reach it at all. Static global variables get internal linkage whether or not they are initialized, as do static functions, const global variables, and unnamed namespaces along with everything declared inside them.
• External linkage: declarations of the name anywhere in the program refer to the same entity. Non-static functions get external linkage, as do non-const global variables (initialized or not), extern const global variables, inline const global variables, and namespaces.

Functions are external by default, which is why calling a function defined in another file works with nothing more than a forward declaration. Writing static in front of a function definition switches it to internal.

All Three Properties in One Program

The program below declares three variables with three different combinations of answers. g_rainfallTotal is a global: global scope, static duration, external linkage. s_showerCount is a static local: block scope, static duration, no linkage. meanPerShower is an ordinary local: block scope, automatic duration, no linkage.

#include <iostream>

int g_rainfallTotal{ 0 };

void recordShower(int millimetres)
{
    static int s_showerCount{ 0 };
    ++s_showerCount;
    g_rainfallTotal += millimetres;

    int meanPerShower{ g_rainfallTotal / s_showerCount };
    std::cout << "shower " << s_showerCount
              << ": running total " << g_rainfallTotal
              << " mm, mean " << meanPerShower << " mm" << '\n';
}

int main()
{
    recordShower(12);
    recordShower(7);
    recordShower(23);

    return 0;
}

shower 1: running total 12 mm, mean 12 mm
shower 2: running total 19 mm, mean 9 mm
shower 3: running total 42 mm, mean 14 mm

The two counters behave identically across calls, since both have static duration and both keep accumulating. What separates them is scope and linkage, neither of which is visible in the output.

Scope Is Not Duration

s_showerCount survives every call to recordShower(), but its name stops working at the function's closing brace. The following program is broken and will not compile, because main() tries to read a name that is not in scope there:

#include <iostream>

void recordShower(int millimetres)
{
    static int s_showerCount{ 0 };
    ++s_showerCount;
    std::cout << "shower " << s_showerCount << ": " << millimetres << " mm" << '\n';
}

int main()
{
    recordShower(12);
    std::cout << s_showerCount << '\n';

    return 0;
}

GCC rejects the line in main() with an error reporting that s_showerCount was not declared in this scope. The object exists at that moment in the program's life, holding the value 1, and there is still no legal way to name it from here. That gap between "exists" and "can be named" is exactly why duration and scope are tracked separately.

Linkage Is Not Scope

Linkage is the property that decides what a second declaration in a second file means. Both globals below have global scope in their own file, and only one of them is reachable from elsewhere.

gauge.cpp:

int g_gaugeReading{ 47 };

static int calibrationOffset()
{
    return 3;
}

int calibratedReading()
{
    return g_gaugeReading + calibrationOffset();
}

main.cpp:

#include <iostream>

extern int g_gaugeReading;
int calibratedReading();

int main()
{
    std::cout << "raw reading: " << g_gaugeReading << " mm" << '\n';
    std::cout << "calibrated reading: " << calibratedReading() << " mm" << '\n';

    return 0;
}

raw reading: 47 mm
calibrated reading: 50 mm

g_gaugeReading and calibratedReading() are external, so the declarations in main.cpp bind to the definitions in gauge.cpp. calibrationOffset() is static and therefore internal: adding a forward declaration of it to main.cpp would compile, then fail at link time, because the linker is not allowed to look inside another translation unit for an internal name.

The Combinations You Will Meet

Each declaration below answers all three questions at once. The table is grouped by reach, from names no other declaration can touch, through names confined to one file, to names the whole program shares.

Read the table sideways rather than down. Moving between the internal and external groups only ever changes one keyword, and it never changes scope or duration.

Declaring Something Defined Elsewhere

A forward declaration introduces a name without defining the entity, so a file can use something another file owns. The declared name follows the ordinary scope rules: written at global scope it is visible to the end of that file, and written inside a block it is visible to the end of that block.

The asymmetry in the first two rows is worth holding on to. A function declaration is unambiguous already, because the missing body is what distinguishes it from a definition, so extern would add nothing. A variable declaration has no such tell, and extern is what marks it as "defined elsewhere" rather than "defined right here".

A constexpr variable is implicitly const, so it can be forward declared through the const form, extern const int g_maxDepthCm;. What crosses the file boundary is const-ness, not constexpr-ness: through that declaration the variable is usable as a const value at runtime, and not as a compile-time constant.

The Keywords That Set Duration and Linkage

C++ groups the keywords that dial in duration and linkage under one name, storage class specifiers. static and extern are the two you have already met; four remain active in modern C++.

The term itself shows up mostly in standards text and compiler documentation rather than in everyday conversation. It is worth recognising, because it explains why static seems to mean unrelated things in different places: on a local it is setting duration, and on a global it is setting linkage.

Looking Forward

Three threads from this lesson get picked up later. Unnamed namespaces are the modern way to give a name internal linkage, and the namespaces lesson covers what they do to the names inside them. Inline variables are what let a header hand the same external constant to every file that includes it. Dynamic duration needs the allocation and deallocation operators, plus the discipline for using them safely, which a later chapter covers in full.

Summary

Every declaration answers three independent questions.

Scope decides where the name may be written. Block scope reaches from the declaration to the end of its block. Global scope reaches from the declaration to the end of the file.

Duration decides when the object exists. Automatic duration spans one pass through a block. Static duration spans the whole program. Dynamic duration spans whatever interval the programmer requests.

Linkage decides which declarations mean the same entity. No linkage keeps every declaration separate. Internal linkage joins declarations within one translation unit. External linkage joins declarations across the whole program.

Locals and parameters answer block, automatic, none. Static locals answer block, static, none, so their value outlives calls that cannot name them. Non-const globals answer global, static, external, and static narrows the last answer to internal. Const and constexpr globals answer global, static, internal, and extern or inline widens the last answer to external.

Reaching a name from another file takes a forward declaration: none for functions, extern with no initializer for non-const and const variables, and nothing at all for constexpr, which cannot be forward declared as constexpr. The keywords that do this work, static and extern among them, are called storage class specifiers because they set storage duration and linkage.