Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Variable `inline` : un seul objet pour plusieurs unités de traduction

Une variable `inline` à liaison externe se définit dans un en-tête partagé. Contrairement au `const` ordinaire à portée d’espace de noms de l’exemple, elle désigne le même objet dans les différentes unités de traduction.

Version : ISO C++23; implementation support may vary

Syntaxe

namespace config {
    inline const int shared_limit = 42;
    const int local_limit = 42;
}

Depuis C++17, le spécificateur inline permet de déclarer une variable inline. Il ne promet ni expansion du code ni exécution plus rapide. Une unité de traduction correspond généralement à un fichier .cpp avec le texte des en-têtes inclus, après prétraitement. La liaison externe permet à des déclarations dans différentes unités de traduction de désigner la même variable.

La règle de définition unique (ODR) interdit de définir deux fois la même variable dans une unité de traduction. Dans les en-têtes ordinaires hors des modules nommés, une variable inline à liaison externe peut néanmoins avoir des définitions concordantes dans différentes unités : elles désignent un seul objet, à une seule adresse. Sa définition doit être accessible depuis la fin de chaque unité où elle est utilisée au sens de l’ODR en dehors d’une instruction écartée. Prendre son adresse avec & dans une expression potentiellement évaluée est un tel usage.

La concordance exige notamment la même suite de jetons après prétraitement. En règle générale, les noms correspondants doivent aussi désigner les mêmes entités. Si une macro modifie l’initialiseur dans une seule unité de sorte que les jetons de la définition diffèrent, le programme est mal formé et aucun diagnostic n’est exigé.

Dans l’en-tête présenté, inline const int shared_limit a une liaison externe, tandis que le simple const int local_limit à portée d’espace de noms a une liaison interne : chaque unité qui inclut l’en-tête a son propre local_limit. Les deux variables ont une durée de stockage statique. inline n’impose pas de liaison externe : static inline à portée d’espace de noms a une liaison interne.

Exemples

// limits.hpp
#ifndef CKTIS_LIMITS_HPP_INCLUDED
#define CKTIS_LIMITS_HPP_INCLUDED

namespace config {
    inline const int shared_limit = 42;
    const int local_limit = 42;
}

#endif

// other.cpp
#include "limits.hpp"

const int* shared_from_other() {
    return &config::shared_limit;
}

const int* local_from_other() {
    return &config::local_limit;
}

// main.cpp
#include "limits.hpp"
#include <iostream>

const int* shared_from_other();
const int* local_from_other();

int main() {
    std::cout << std::boolalpha
              << "shared: " << (&config::shared_limit == shared_from_other()) << '\n'
              << "local: " << (&config::local_limit == local_from_other()) << '\n';
}

Résultat

shared: true
local: false

Les deux fichiers `.cpp` incluent le même en-tête. L’opérateur `==` compare les pointeurs, pas les valeurs `42` : il donne `true` pour `shared_limit` et `false` pour les deux objets `local_limit` distincts.

Leçons associées

  • C++ · Leçon 7 · Avancé · Version : 3

Sources