KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Translatie-eenheden, linkage en de ODR

Translatie-eenheden maken het mogelijk delen van een programma afzonderlijk te vertalen. Linkage bepaalt de identiteit van namen tussen declaraties, terwijl de ODR het aantal en de vorm van definities beperkt. Als je deze begrippen uit elkaar houdt, kun je code goed verdelen over headers en implementatiebestanden.

Versie: C++23; repository compiler flag, production runtime not attested

Syntax

extern int counter; // declaration
int counter = 0; // definition
static int local_counter = 0; // namespace-scope internal linkage
namespace { int private_counter = 0; }

Translatie-eenheid

In een typisch programma zonder modules is een translatie-eenheid een verwerkt bronbestand samen met de inhoud die via #include is ingevoegd, na voorwaardelijke compilatie. Een header is dus niet automatisch een aparte eenheid. Eenheden kunnen afzonderlijk worden vertaald en daarna worden gelinkt.

Linkage en scope

Scope bepaalt waar een naam gevonden kan worden; linkage bepaalt of declaraties naar dezelfde entiteit kunnen verwijzen. External linkage maakt het mogelijk dat declaraties in verschillende eenheden bij elkaar horen. Internal linkage beperkt ze tot één eenheid; onder meer static op namespace-niveau en naamloze namespaces zorgen hiervoor. Module linkage betreft declaraties die aan dezelfde benoemde module zijn gekoppeld. Een gewone lokale variabele heeft geen linkage. Linkage bepaalt niet de levensduur van een object.

ODR — one-definition rule

De declaratie extern int counter; definieert geen object; int counter = 0; doet dat wel. Dezelfde definieerbare entiteit mag niet herhaaldelijk binnen één eenheid worden gedefinieerd. Een functie of variabele die buiten een verworpen statement op een manier wordt gebruikt waarvoor een definitie vereist is (odr-use), moet een definitie hebben. Een gewone functie of variabele die geen template of inline is, mag niet meerdere definities in het programma hebben. Klassentypen, templates en inline-entiteiten mogen alleen onder de ODR-voorwaarden in meerdere eenheden worden gedefinieerd. Die voorwaarden omvatten onder meer overeenkomende tokens en naamopzoeking, en dat ze niet aan een benoemde module gekoppeld zijn. Niet elke schending vereist een diagnose.

Voorbeeld en beperkingen

counter.cpp en main.cpp vormen twee eenheden. Beide declareren dezelfde counter, maar alleen het eerste bestand definieert die; step blijft intern. De header guard voorkomt herhaalde headerinhoud binnen één eenheid, maar geen dubbele definities tussen eenheden. De bronnen verwijzen naar een ontwerp van de C++-standaard waaraan nog wordt gewerkt, niet naar de vastgestelde tekst van C++23. Het voorbeeld is bedoeld voor lokale controle met de C++23-optie en geeft geen garantie voor een productieomgeving.

Referentie-identificatoren die in dit item worden behandeld: ODR / linkage / translation unit.

Voorbeelden

// counter.hpp
#ifndef COUNTER_HPP
#define COUNTER_HPP
extern int counter;
int next();
#endif

// counter.cpp
#include "counter.hpp"
namespace { int step = 2; }
int counter = 0;
int next() { return counter += step; }

// main.cpp
#include "counter.hpp"
#include <iostream>
int main() {
    std::cout << next() << '\n';
    std::cout << counter << '\n';
}

Resultaat

2
2

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen