KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

`inline`-variabele: één object in meerdere vertaaleenheden

Een `inline`-variabele met externe koppeling kan in een gedeelde header worden gedefinieerd. Anders dan de gewone `const` op namespaceniveau in het voorbeeld duidt die in verschillende vertaaleenheden hetzelfde object aan.

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

Syntax

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

Sinds C++17 kun je met de specificatie inline een inline-variabele declareren. Dat belooft niet dat code wordt ingevoegd of sneller wordt uitgevoerd. Een vertaaleenheid is doorgaans een .cpp-bestand met de tekst van de opgenomen headers na voorverwerking. Externe koppeling maakt het mogelijk dat declaraties in verschillende vertaaleenheden dezelfde variabele aanduiden.

De One Definition Rule (ODR) verbiedt om dezelfde variabele twee keer in één vertaaleenheid te definiëren. In gewone headers buiten benoemde modules mag een inline-variabele met externe koppeling toch overeenkomende definities in verschillende vertaaleenheden hebben: die duiden één object met één adres aan. De definitie moet bereikbaar zijn vanaf het einde van iedere vertaaleenheid waar de variabele buiten een verworpen statement in de zin van de ODR wordt gebruikt. Het adres nemen met & in een potentieel geëvalueerde expressie is zo’n gebruik.

Overeenstemming vereist onder meer dezelfde reeks tokens na voorverwerking. Overeenkomstige namen moeten meestal ook naar dezelfde entiteiten verwijzen. Als een macro de initializer in slechts één vertaaleenheid zo verandert dat de tokens van de definitie verschillen, is het programma niet welgevormd en is een diagnose niet verplicht.

In de getoonde header heeft inline const int shared_limit externe koppeling. De gewone const int local_limit op namespaceniveau heeft interne koppeling: elke vertaaleenheid die de header opneemt, heeft een eigen local_limit. Beide variabelen hebben statische opslagduur. inline dwingt geen externe koppeling af: static inline op namespaceniveau heeft interne koppeling.

Voorbeelden

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

Resultaat

shared: true
local: false

Beide `.cpp`-bestanden nemen dezelfde header op. De operator `==` vergelijkt pointers, niet de waarden `42`: de uitkomst is `true` voor `shared_limit` en `false` voor de twee verschillende `local_limit`-objecten.

Gerelateerde lessen

  • C++ · Les 7 · Gevorderd · Versie: 3

Bronnen