once pragma

Spécifie que le compilateur inclut le fichier d’en-tête une seule fois, lors de la compilation d’un fichier de code source.

Syntaxe

#pragma once

Notes

L’utilisation de peut réduire les temps de #pragma once génération, car le compilateur ne s’ouvre pas et ne lit plus le fichier après le premier #include du fichier dans l’unité de traduction. Il s’agit de l’optimisation à plusieurs inclure. Il a un effet similaire à l’idiome include guard , qui utilise des définitions de macro de préprocesseur pour empêcher plusieurs inclusions du contenu du fichier. Il permet également d’éviter les violations de la règle de définition unique : l’exigence que tous les modèles, types, fonctions et objets n’ont pas plus d’une définition dans votre code.

Par exemple :

// header.h
#pragma once
// Code placed here is included only once per translation unit

Nous vous recommandons la directive #pragma once pour le nouveau code, car elle ne pollue pas l'espace de noms global avec un symbole de préprocesseur. Il nécessite moins de frappe, il est moins distrait, et il ne peut pas provoquer de collisions de symboles. Les collisions de symboles sont provoquées lorsque différents fichiers d’en-tête utilisent le même symbole de préprocesseur que la valeur de protection. Elle ne fait pas partie de la norme C++, mais elle est implémentée de manière portable par plusieurs compilateurs courants.

Il n’existe aucun avantage à utiliser les deux idiomes de protection et #pragma once dans le même fichier. Le compilateur reconnaît l’idiome include guard et implémente l’optimisation multi-include de la même façon que la #pragma once directive si aucun code non-commentaire ou directive de préprocesseur n’est fourni avant ou après la forme standard de l’idiome :

// header.h
// Demonstration of the #include guard idiom.
// Note that the defined symbol can be arbitrary.
#ifndef HEADER_H_     // equivalently, #if !defined HEADER_H_
#define HEADER_H_
// Code placed here is included only once per translation unit
#endif // HEADER_H_

Nous vous recommandons d’inclure l’idiome de protection lorsque le code doit être portable pour les compilateurs qui n’implémentent pas la directive, pour maintenir la #pragma once cohérence avec le code existant ou lorsque l’optimisation à plusieurs inclure est impossible. Il peut se produire dans des projets complexes lorsque les chemins d’accès d’alias ou d’alias du système de fichiers empêchent le compilateur d’identifier les fichiers include identiques par chemin canonique.

Veillez à ne pas utiliser #pragma once ou à inclure l’idiome de garde dans les fichiers d’en-tête conçus pour être inclus plusieurs fois, qui utilisent des symboles de préprocesseur pour contrôler leurs effets. Pour obtenir un exemple de cette conception, consultez le <fichier d’en-tête assert.h> . Veillez également à gérer vos chemins d’accès Include pour éviter de créer plusieurs chemins d’accès à des fichiers inclus, ce qui peut vaincre l’optimisation à plusieurs inclusions pour les deux gardes #pragma onceet .

Voir aussi

Directives pragma et les __pragma_Pragma mot clé