> ## 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++ Inline Member Variable
An inline member variable is a `static` data member declared with the `inline` specifier, allowing it to be defined and initialized directly within a class definition without violating the One Definition Rule (ODR). Introduced in C++17, it instructs the compiler and linker to permit multiple identical definitions of the variable across different translation units, ultimately merging them into a single, shared memory address during the linking phase.
## Syntax
To declare an inline member variable, apply the `inline` keyword to a `static` member declaration and provide its initializer.
```cpp theme={"dark"}
class GlobalState {
public:
// Explicitly declared inline static member
inline static int connection_count = 0;
// Implicitly inline (C++17 onwards, constexpr implies inline for static members)
static constexpr double timeout_threshold = 5.5;
};
```
## Mechanical Behavior and Rules
**1. One Definition Rule (ODR) Resolution**
Historically, a `static` class member required a single out-of-line definition in exactly one source (`.cpp`) file. If defined in a header included by multiple translation units, the linker would throw a multiple-definition error. The `inline` specifier changes this linkage behavior. The compiler emits the symbol in each translation unit, and the linker discards all but one instance, ensuring all references point to the exact same memory location.
**2. Implicit `inline` via `constexpr`**
As of C++17, any `static constexpr` data member is implicitly `inline`. You do not need to explicitly write the `inline` keyword, and you no longer need to provide a redundant out-of-line definition for it to be ODR-used (e.g., when taking its address).
**3. Identical Definitions Requirement**
If an inline member variable is defined in multiple translation units, every definition must be token-for-token identical. If the initializers differ across translation units, the program is ill-formed, no diagnostic required (NDR), which typically results in undefined behavior.
**4. Initialization Sequencing**
Inline static variables with dynamic initialization are initialized before `main()` begins. If multiple inline variables exist across different translation units, their initialization order is partially ordered based on the inclusion order within the translation units, though constant initialization (evaluated at compile-time) is always performed first.
## Structural Comparison
To understand the mechanical shift, compare the pre-C++17 requirement with the C++17 inline variable mechanism:
**Pre-C++17 (Requires separate declaration and definition):**
```cpp theme={"dark"}
// Header file (.h)
class LegacyClass {
static int instance_count; // Declaration only
};
// Source file (.cpp)
int LegacyClass::instance_count = 0; // Definition and initialization
```
**C++17 (Unified declaration and definition):**
```cpp theme={"dark"}
// Header file (.h)
class ModernClass {
inline static int instance_count = 0; // Declaration, definition, and initialization
};
// No .cpp file definition required.
```
Tired of Poor C++ Skills? Fix That With Deep Grasping!
Learn More
