Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Variabile `inline`: un solo oggetto in più unità di traduzione

Una variabile `inline` con linkage esterno si può definire in un header condiviso. A differenza della normale variabile `const` a livello di namespace dell’esempio, indica lo stesso oggetto nelle diverse unità di traduzione.

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

Sintassi

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

Da C++17 lo specificatore inline può dichiarare una variabile inline. Non promette né l’espansione del codice né un’esecuzione più veloce. Un’unità di traduzione è tipicamente un file .cpp con il testo degli header inclusi, dopo la preelaborazione. Il linkage esterno permette a dichiarazioni in diverse unità di traduzione di indicare la stessa variabile.

La regola della definizione unica (ODR) vieta di definire due volte la stessa variabile in una singola unità di traduzione. Negli header ordinari al di fuori dei moduli con nome, una variabile inline con linkage esterno può tuttavia avere definizioni corrispondenti in più unità: indicano un solo oggetto con un solo indirizzo. La definizione deve essere raggiungibile dalla fine di ogni unità in cui la variabile è usata ai sensi della ODR al di fuori di un’istruzione scartata. Prendere il suo indirizzo con & in un’espressione potenzialmente valutata costituisce un uso di questo tipo.

Tra i requisiti di corrispondenza c’è la stessa sequenza di token dopo la preelaborazione. Di norma, i nomi corrispondenti devono anche risolversi nelle stesse entità. Se una macro cambia l’inizializzatore in una sola unità e i token della definizione diventano diversi, il programma è mal formato e non è richiesta alcuna diagnostica.

Nell’header mostrato, inline const int shared_limit ha linkage esterno; la normale variabile const int local_limit a livello di namespace ha linkage interno: ogni unità che include l’header ha il proprio local_limit. Entrambe le variabili hanno durata di memorizzazione statica. inline non impone il linkage esterno: static inline a livello di namespace ha linkage interno.

Esempi

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

Risultato

shared: true
local: false

Entrambi i file `.cpp` includono lo stesso header. L’operatore `==` confronta i puntatori, non i valori `42`: restituisce `true` per `shared_limit` e `false` per i due oggetti `local_limit` distinti.

Lezioni correlate

  • C++ · Lezione 7 · Avanzato · Versione: 3

Fonti