> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C++ Global Variable
A global variable in C++ is a variable declared at namespace scope (either the global namespace `::` or within a named namespace), outside of any function, class, or block. It possesses static storage duration, meaning its memory is allocated when the program begins execution and is deallocated only when the program terminates.
## Technical Characteristics
* **Scope:** Namespace scope. It is visible from its point of declaration to the end of the translation unit. It can be shadowed by local variables with the same name, but the global instance remains accessible via the scope resolution operator (e.g., `::variable_name` or `Namespace::variable_name`).
* **Lifetime:** Static storage duration.
* **Initialization:** All global variables undergo zero-initialization during the static initialization phase, regardless of whether they have an explicit initializer. If an explicit initializer is provided, constant initialization occurs next (if applicable), followed by dynamic initialization (e.g., calling a function to set the value) before `main()` executes.
* **Linkage:** By default, non-const global variables possess external linkage, meaning the same memory location can be referenced across multiple translation units (source files).
## External Linkage and Sharing Across Translation Units
To share a global variable across multiple translation units, it must satisfy the One Definition Rule (ODR). C++ provides two primary mechanisms for this:
**1. Inline Variables (C++17 and later)**
The modern standard practice is to use the `inline` keyword. This allows the global variable to be defined directly in a header file. The linker will automatically merge all identical definitions into a single memory location, satisfying the ODR.
```cpp theme={"dark"}
// globals.h
inline int g_system_state = 1; // Defined in header, shared across all files including this header
```
**2. Traditional Extern Declarations (Pre-C++17)**
Before C++17, a global variable had to be defined exactly once in a single source file and declared using the `extern` keyword in any other file (or header) that required access to it.
```cpp theme={"dark"}
// globals.cpp (Definition - Allocates memory)
int g_system_state = 1;
// main.cpp (Declaration - References existing memory)
extern int g_system_state;
int main() {
g_system_state = 2;
return 0;
}
```
## Internal Linkage
If a global variable should be restricted to the translation unit in which it is defined, its linkage must be changed to internal. This prevents linker collisions if another file defines a global variable with the identical name.
There are two ways to achieve internal linkage:
**1. Unnamed Namespaces (Modern C++ standard practice)**
```cpp theme={"dark"}
namespace {
int g_local_counter = 0; // Visible only within this translation unit
}
```
**2. The `static` keyword (Legacy C-style)**
```cpp theme={"dark"}
static int g_local_counter = 0; // Visible only within this translation unit
```
## Constant Global Variables (`const` and `constexpr`)
Unlike standard global variables, variables declared at namespace scope with `const` or `constexpr` implicitly default to **internal linkage**. Placing a standard `const` or `constexpr` variable in a header file does not violate the ODR; it simply results in a distinct, safe copy of the variable in each translation unit that includes the header.
```cpp theme={"dark"}
const int g_max_connections = 100; // Internal linkage by default
constexpr int g_timeout_ms = 5000; // Internal linkage by default
```
To give these variables **external linkage** so that they resolve to the exact same memory address across the entire program, specific syntax is required:
**Sharing `const` variables:**
The `extern` keyword must be explicitly applied to both the definition and the declaration.
```cpp theme={"dark"}
// globals.cpp (Definition)
extern const int g_max_connections = 100;
// globals.h (Declaration)
extern const int g_max_connections;
```
**Sharing `constexpr` variables:**
The `extern` declaration pattern cannot be used for `constexpr` variables because `constexpr` requires an immediate initializer. To share a `constexpr` global across translation units as a single memory location, it must be defined in a header file using `inline constexpr` (introduced in C++17).
```cpp theme={"dark"}
// config.h
inline constexpr int g_timeout_ms = 5000; // External linkage, single memory address
```
## The Static Initialization Order Fiasco
A critical mechanical behavior of C++ global variables is that the order of dynamic initialization for standard global variables defined in *different* translation units is **unspecified**.
If a global variable in `fileA.cpp` relies on a global variable in `fileB.cpp` being initialized first, the program's state is unpredictable. Relying on this unspecified initialization order is known as the "Static Initialization Order Fiasco" and often results in Undefined Behavior (UB) if the program accesses memory that has been zero-initialized but not yet dynamically initialized. (Note: C++17 introduced partially-ordered initialization specifically for `inline` variables, but the initialization order of standard global variables across translation units remains unspecified).
Tired of Poor C++ Skills? Fix That With Deep Grasping!
Learn More
