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

CKTIS / C++

Unités de traduction, linkage et ODR

Les unités de traduction permettent de traduire séparément différentes parties d’un programme. Le linkage détermine l’identité des noms entre les déclarations, tandis que l’ODR limite le nombre et la forme des définitions. Distinguer ces notions aide à répartir correctement le code entre les en-têtes et les fichiers d’implémentation.

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

Syntaxe

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

Unité de traduction

Dans un programme typique sans modules, une unité de traduction est un fichier source traité avec le contenu inclus au moyen de #include, après la compilation conditionnelle. Un en-tête ne constitue donc pas automatiquement une unité distincte. Les unités peuvent être traduites séparément, puis liées.

Linkage et portée

La portée détermine où un nom peut être trouvé ; le linkage détermine si des déclarations peuvent désigner la même entité. Le linkage externe permet à des déclarations de correspondre entre unités. Le linkage interne les limite à une seule unité ; static à portée d’espace de noms et les espaces de noms sans nom le fournissent, entre autres cas. Le linkage de module concerne les déclarations rattachées au même module nommé. Une variable locale ordinaire n’a aucun linkage. Le linkage ne détermine pas la durée de vie d’un objet.

ODR — règle de définition unique

La déclaration extern int counter; ne définit pas d’objet ; int counter = 0; le définit. Une même entité définissable ne peut pas être définie plusieurs fois dans une unité. Une fonction ou une variable utilisée d’une manière qui exige une définition (odr-use), en dehors d’une instruction supprimée, doit avoir une définition. Une fonction ou variable ordinaire qui n’est ni un modèle ni inline ne peut pas avoir plusieurs définitions dans le programme. Les types de classe, les modèles et les entités inline ne peuvent être définis dans plusieurs unités que si les conditions de l’ODR sont respectées. Elles comprennent notamment la concordance des jetons et de la recherche de noms, ainsi que l’absence de rattachement à un module nommé. Toute violation ne nécessite pas forcément un diagnostic.

Exemple et limites

counter.cpp et main.cpp forment deux unités. Les deux déclarent le même counter, mais seul le premier fichier le définit ; step reste interne. La garde d’inclusion empêche la répétition du contenu de l’en-tête dans une unité, pas les définitions en double entre unités. Les sources constituent un projet de norme en évolution, et non un texte C++23 figé. L’exemple est destiné à une vérification locale avec l’option C++23, sans attester d’un environnement d’exécution de production.

Identifiants de référence couverts par cette entrée : ODR / linkage / translation unit.

Exemples

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

Résultat

2
2

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources