Scope, Duration, and Linkage recap

Excellent work! You've covered substantial material in this section on control flow, scope, and program structure. Let's review the key concepts you've learned.

Compound statements and blocks

A compound statement or block is a group of zero or more statements the compiler treats as a single statement. Blocks begin with {, end with }, with statements to execute placed between. Blocks can be used anywhere a single statement is allowed. No semicolon is needed at a block's end. Blocks are often used with if statements to execute multiple statements.

User-defined namespaces

User-defined namespaces are namespaces you define for your own declarations. Namespaces provided by C++ (like the global namespace) or by libraries (like namespace std) are not considered user-defined namespaces.

You can access a declaration in a namespace via the scope resolution operator (::). The scope resolution operator tells the compiler that the identifier specified by the right-hand operand should be looked for in the scope of the left-hand operand. If no left-hand operand is provided, the global namespace is assumed.

Local variables and scope

Local variables are variables defined within a function (including function parameters). Local variables have block scope, meaning they are in scope from their definition point to the end of the block they're defined within. Local variables have automatic storage duration, meaning they are created at their definition point and destroyed at the end of the block they're defined in.

A name declared in a nested block can shadow or name hide an identically named variable in an outer block. This should be avoided.

Global variables and linkage

Global variables are variables defined outside functions. Global variables have file scope, visible from their declaration point until the end of the file where they're declared. Global variables have static duration, created when the program starts and destroyed when it ends. Avoid dynamic initialization of static variables whenever possible.

An identifier's linkage determines whether other declarations of that name refer to the same object or not. Local variables have no linkage. Identifiers with internal linkage can be seen and used within a single file, but are not accessible from other files. Identifiers with external linkage can be seen and used both from the file where they're defined and from other code files (via forward declaration).

Avoid non-const global variables whenever possible. Const globals are generally acceptable. Use inline variables for global constants if your compiler is C++17 capable.

Static local variables

Local variables can be given static duration via the static keyword.

Qualified and unqualified names

A qualified name is a name that includes an associated scope (e.g., std::string). An unqualified name is a name without a scoping qualifier (e.g., string).

Using statements

Using statements (including using declarations and using directives) can be used to avoid qualifying identifiers with explicit namespaces. A using declaration allows us to use an unqualified name (with no scope) as an alias for a qualified name. A using directive imports all identifiers from a namespace into the scope of the using directive. Both should generally be avoided.

Inline functions and variables

Inline expansion is a process where a function call is replaced by the code from the called function's definition. A function declared using the inline keyword is called an inline function.

Inline functions and variables have two primary requirements:

  • The compiler needs to see the full definition of an inline function or variable in each translation unit where it's used (a forward declaration alone won't suffice). The definition can occur after the point of use if a forward declaration is also provided.
  • Every definition for an inline function or variable must be identical; otherwise, undefined behavior results.

In modern C++, the term inline has evolved to mean "multiple definitions are allowed." Thus, an inline function is one allowed to be defined in multiple files. C++17 introduced inline variables, which are variables allowed to be defined in multiple files.

Inline functions and variables are particularly useful for header-only libraries, which are one or more header files implementing some capability (no .cpp files are included).

Unnamed and inline namespaces

Finally, C++ supports unnamed namespaces, which implicitly treat all namespace contents as having internal linkage. C++ also supports inline namespaces, which provide primitive versioning capabilities for namespaces.

Key Terminology

  • Compound statement/Block: Group of statements treated as a single statement, enclosed in braces
  • User-defined namespace: Namespace defined by you for your own declarations
  • Scope resolution operator (::): Operator for accessing declarations in a namespace
  • Block scope: Scope from definition point to end of the block
  • Automatic storage duration: Variables created at definition and destroyed at block end
  • Shadow/Name hide: When a nested block declaration hides an outer block identifier
  • File scope: Global variables visible from declaration to end of file
  • Static duration: Variables created at program start and destroyed at program end
  • Linkage: Determines whether declarations of the same name refer to the same object
  • Internal linkage: Visible within a single file only
  • External linkage: Visible across multiple files
  • Inline variable: Variable allowed to be defined in multiple files (C++17)
  • static keyword: Gives local variables static duration
  • Qualified name: Name including associated scope (e.g., std::string)
  • Unqualified name: Name without scoping qualifier (e.g., string)
  • Using declaration: Allows using an unqualified name as alias for qualified name
  • Using directive: Imports all identifiers from a namespace
  • Inline expansion: Process where function call is replaced by function body
  • Inline function: Function declared with inline keyword
  • Header-only library: Library implemented entirely in header files
  • Unnamed namespace: Namespace implicitly treating contents as having internal linkage
  • Inline namespace: Namespace providing versioning capabilities

Looking Forward

This section covered fundamental concepts about program structure, scope, and lifetime that are essential for writing well-organized C++ programs. Understanding blocks, namespaces, linkage, and storage duration will help you avoid common pitfalls and write more maintainable code. The concepts of inline functions and variables, along with proper namespace usage, are particularly important for modern C++ development. As you continue learning, these foundational principles will support more advanced topics like classes, templates, and larger project organization.