Inline-переменные и одноопределимое правило (ODR) в современном C++

Введение

One Definition Rule (ODR, «правило одного определения») — одно из фундаментальных, но часто неочевидных правил C++: любая сущность (функция, переменная, класс, шаблон) должна иметь ровно одно определение во всей программе (с некоторыми исключениями для шаблонов и inline-сущностей). Нарушение ODR — частый источник трудноуловимых ошибок линковки или, что хуже, неопределённого поведения, которое может даже не проявиться сразу. C++17 добавил inline-переменные — инструмент, который элегантно решает классическую проблему определения статических членов класса и глобальных констант в заголовочных файлах.

Проблема, которую решает inline-переменная

До C++17 нельзя было просто определить переменную в заголовочном файле, который подключается в несколько .cpp файлов — линковщик увидел бы несколько определений одной и той же переменной и выдал ошибку multiple definition.

// config.h — ДО C++17, проблемный код
class Config
{
public:
    static const int MaxConnections = 100; // OK только для const integral со значением-константой,
                                            // и то это не настоящее определение, а decl + значение
    static std::string DefaultHost; // объявление — требует отдельного определения в .cpp!
};

// Раньше требовалось в config.cpp написать:
// std::string Config::DefaultHost = "localhost";
// Забыть про этот .cpp — частая причина ошибок линковки "undefined reference".

Решение с inline-переменными (C++17)

// config.h — после C++17
#pragma once
#include <string>

class Config
{
public:
    // inline-переменная: можно определить прямо в заголовочном файле,
    // и при включении этого заголовка в несколько .cpp файлов
    // линковщик не будет считать это нарушением ODR.
    static inline std::string defaultHost = "localhost";
    static inline int maxConnections = 100;
};

// Глобальная inline-переменная вне класса — тоже допустима с C++17
inline constexpr double kPi = 3.14159265358979323846;

// translation_unit_a.cpp
#include "config.h"
#include <iostream>

void printConfigFromA()
{
    std::cout << "[A] host = " << Config::defaultHost << std::endl;
    std::cout << "[A] pi = " << kPi << std::endl;
}

// translation_unit_b.cpp
#include "config.h"
#include <iostream>

void printConfigFromB()
{
    Config::defaultHost = "example.com"; // меняем общее значение
    std::cout << "[B] host = " << Config::defaultHost << std::endl;
}

int main()
{
    extern void printConfigFromA();
    printConfigFromA();
    printConfigFromB();
    printConfigFromA(); // увидит изменённое значение — это одна и та же переменная!
    return 0;
}

Разбор примера

Заголовочный файл config.h подключается в обоих .cpp файлах. Без inline компилятор сгенерировал бы по одному определению Config::defaultHost в каждой единице трансляции (translation unit), и линковщик увидел бы дублирование — ошибку ODR. Ключевое слово inline для переменных говорит компилятору и линковщику: «во всех единицах трансляции, где встречается это определение, считайте их одной и той же сущностью, выберите любое одно фактическое размещение в памяти».

Именно поэтому printConfigFromA() после вызова printConfigFromB() увидит изменённое значение defaultHost — это действительно одна-единственная переменная в памяти программы, а не несколько независимых копий в разных единицах трансляции.

Обратите внимание на kPi — это inline-переменная вне класса, объявленная прямо в заголовочном файле, и она тоже может безопасно подключаться в любое количество .cpp файлов.

ODR и шаблоны

Важно понимать, что шаблоны (функции и классы) уже исторически были «исключением» из строгого ODR — компилятор разрешал множественные идентичные определения шаблона в разных единицах трансляции именно потому, что шаблонный код обычно целиком лежит в заголовках и инстанцируется в каждом .cpp, где используется. inline-переменные расширили эту логику с шаблонов и функций на обычные переменные.

// Функции inline и так давно существовали для той же цели:
inline int square(int x) { return x * x; } // можно определить в .h файле

// C++17 добавил симметричную возможность для переменных:
inline int callCount = 0; // тоже можно определить в .h файле

Подводные камни и советы

Не путайте inline как «подсказку компилятору встроить код» (историческое значение для функций, которое современные компиляторы в основном игнорируют, принимая решение самостоятельно) и inline как «разрешение на множественные определения» (актуальное значение и для функций, и — с C++17 — для переменных). Второе значение сегодня практически важнее первого.
Статические члены класса, объявленные constexpr, неявно являются inline начиная с C++17 — отдельное определение в .cpp для них больше не требуется (в отличие от C++11/14, где для одного лишь объявления static constexpr внутри класса всё равно требовалось определение в .cpp, если переменная использовалась как lvalue, то есть, например, передавалась по ссылке).
Глобальные inline-переменные в заголовках — это всё ещё глобальное изменяемое состояние, со всеми его недостатками (неявные зависимости, проблемы при многопоточном доступе без синхронизации, сложность тестирования). Используйте inline для констант и синглтон-подобных объектов осознанно, не как способ обойти архитектурные проблемы.
Порядок инициализации inline-переменных в разных единицах трансляции не определён, как и для любых глобальных переменных в C++ (classic static initialization order fiasco) — если одна inline-переменная при инициализации зависит от другой inline-переменной из другого файла, возможна неопределённость порядка. Для безопасной ленивой инициализации используйте функцию с локальной static-переменной (Singleton через function-local static, инициализация которой гарантированно потокобезопасна с C++11).
Нарушение ODR не всегда обнаруживается компилятором или линковщиком. Если в разных единицах трансляции оказались разные (а не идентичные) определения одной и той же inline-сущности — например, из-за разных версий заголовочного файла или разных значений макроса при компиляции — поведение программы не определено, и обнаружить такую ошибку может быть очень сложно. Поддерживайте единообразие заголовков и не оборачивайте inline-определения в условную компиляцию, зависящую от макросов, которые могут отличаться между единицами трансляции.

Inline-переменные — небольшое, но важное дополнение C++17, которое окончательно избавляет от необходимости писать парные .h/.cpp определения для констант и статических членов классов, делая заголовочные файлы по-настоящему самодостаточными.