WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

`inline`-Variable: ein Objekt über mehrere Übersetzungseinheiten hinweg

Eine `inline`-Variable mit externer Bindung kann in einem gemeinsamen Header definiert werden. Anders als das gewöhnliche `const` auf Namensraumebene im Beispiel bezeichnet sie in allen Übersetzungseinheiten dasselbe Objekt.

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

Syntax

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

Seit C++17 kann der Spezifizierer inline eine inline-Variable deklarieren. Er verspricht weder das Einsetzen von Code noch eine schnellere Ausführung. Eine Übersetzungseinheit ist typischerweise eine .cpp-Datei samt dem Text der eingebundenen Header nach der Präprozessorverarbeitung. Externe Bindung ermöglicht es, dass Deklarationen in verschiedenen Übersetzungseinheiten dieselbe Variable bezeichnen.

Die Ein-Definitions-Regel (ODR) verbietet es, dieselbe Variable in einer Übersetzungseinheit zweimal zu definieren. In gewöhnlichen Headern außerhalb benannter Module darf eine inline-Variable mit externer Bindung dennoch übereinstimmende Definitionen in verschiedenen Übersetzungseinheiten haben: Sie bezeichnen ein Objekt mit einer Adresse. Die Definition muss vom Ende jeder Übersetzungseinheit aus erreichbar sein, in der die Variable außerhalb einer verworfenen Anweisung im Sinne der ODR verwendet wird. Die Adressbildung mit & in einem potenziell ausgewerteten Ausdruck ist eine solche Verwendung.

Übereinstimmung erfordert unter anderem dieselbe Tokenfolge nach der Präprozessorverarbeitung. Entsprechende Namen müssen sich im Allgemeinen auch auf dieselben Entitäten beziehen. Ändert ein Makro den Initialisierer nur in einer Übersetzungseinheit so, dass sich die Token der Definition unterscheiden, ist das Programm nicht wohlgeformt; eine Diagnose ist nicht vorgeschrieben.

Im gezeigten Header hat inline const int shared_limit externe Bindung, das gewöhnliche const int local_limit auf Namensraumebene dagegen interne Bindung: Jede Übersetzungseinheit, die den Header einbindet, hat ihr eigenes local_limit. Beide Variablen haben statische Speicherdauer. inline erzwingt keine externe Bindung: static inline hat auf Namensraumebene interne Bindung.

Beispiele

// 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';
}

Ergebnis

shared: true
local: false

Beide `.cpp`-Dateien binden denselben Header ein. `==` vergleicht Zeiger, nicht die Werte `42`: Für `shared_limit` ergibt der Vergleich `true`, für die beiden verschiedenen `local_limit`-Objekte `false`.

Zugehörige Lektionen

  • C++ · Lektion 7 · Fortgeschritten · Version: 3

Quellen