Le #pragma est-il une fois un garde d'inclusion sûr ?

Question

J'ai lu qu'il y a une certaine optimisation du compilateur lors de l'utilisation de #pragma once ce qui peut permettre une compilation plus rapide. Je reconnais que ce n'est pas standard, et que cela pourrait donc poser un problème de compatibilité entre plates-formes.

Est-ce quelque chose qui est supporté par la plupart des compilateurs modernes sur les plateformes non-Windows (gcc) ?

Je veux éviter les problèmes de compilation des plates-formes, mais je veux aussi éviter le travail supplémentaire des gardes de repli :

#pragma once
#ifndef HEADER_H
#define HEADER_H

...

#endif // HEADER_H

Dois-je m'inquiéter ? Devrais-je dépenser davantage d'énergie mentale à ce sujet ?

Answer 1

#pragma once a un inconvénient (autre que celui d'être non standard) et c'est que si vous avez le même fichier à différents endroits (nous avons cela parce que notre système de construction copie les fichiers autour) alors le compilateur pensera que ce sont des fichiers différents.

Answer 2

Utilisation de #pragma once devrait fonctionner sur n'importe quel compilateur moderne, mais je ne vois pas pourquoi on ne pourrait pas utiliser une norme #ifndef inclure la garde. Cela fonctionne très bien. La seule réserve est que GCC n'a pas supporté #pragma once avant version 3.4 .

J'ai également constaté que, au moins sur GCC, il reconnaît la norme #ifndef inclure la garde et l'optimiser donc il ne devrait pas être beaucoup plus lent que #pragma once .

Answer 3

Je souhaite #pragma once (ou quelque chose comme ça) avait été dans la norme. Les protections d'inclusion ne sont pas vraiment un gros problème (mais elles semblent être un peu difficiles à expliquer aux personnes qui apprennent le langage), mais cela semble être un inconvénient mineur qui aurait pu être évité.

En effet, puisque dans 99,98% des cas, le #pragma once est le comportement souhaité, il aurait été intéressant que la prévention de l'inclusion multiple d'un en-tête soit automatiquement gérée par le compilateur, avec une balise #pragma ou quelque chose pour permettre la double inclusion.

Mais nous avons ce que nous avons (sauf que vous pourriez ne pas avoir #pragma once ).

Answer 4

Je ne sais pas s'il y a des avantages en termes de performance, mais cela fonctionne certainement. Je l'utilise dans tous mes projets C++ (bien que j'utilise le compilateur MS). Je trouve que c'est plus efficace que d'utiliser

#ifndef HEADERNAME_H
#define HEADERNAME_H
...
#endif

Il fait le même travail et ne remplit pas le préprocesseur avec des macros supplémentaires.

Le GCC prend en charge #pragma once officiellement à partir de la version 3.4 .

Answer 5

Utilisation ' #pragma once peut ne pas avoir d'effet (il n'est pas supporté partout - bien qu'il soit de plus en plus largement supporté), et vous devez donc utiliser le code de compilation conditionnelle de toute façon, auquel cas, pourquoi s'embêter avec ' #pragma once ' ? Le compilateur l'optimise probablement de toute façon. Cela dépend cependant de vos plateformes cibles. Si toutes vos cibles le supportent, alors allez-y et utilisez-le - mais cela doit être une décision consciente parce que l'enfer se déchaînera si vous n'utilisez que le pragma et que vous le portez sur un compilateur qui ne le supporte pas.