je reste #pragma tique

Salut les C,

"Ceci n'est pas un poste d'un sujet méritant qu'on le classe dans la section débutant mais comme la section avancé n'existe pas je poste ici."

Je suis en train de lire un excellent bouquin traitant de library de tout genre, ou plutôt sous tout le formats: static, shared, Linux *.dll et Windows.

Mais aussi beaucoup de code machine (Le format ELF) et de désassemblage.

Et je me posait la question qu'est-ce que fait exactement la directive de prépocesseur #pragma véritablement ?

Ou plutôt comment en donner une définition claire et ce que fait ce #pragma

Par exemple l'auteur du livre commence ses en-tête avec

Code:

---

#pragma once

---

Et j'ai appris que l'on pouvait cacher des symboles grace au #pragma("hidden").

Ou alors que l'on pouvait changer de version une fonction d'une bibliothèque

dans le cas énoncé dans le livre il s'agissait du sens de la valeur de retour d'une fonction, selon la version mineure de la bibliothèque.

Qui dans un cas donnait un résultat en millisecondes et dans l'autre en nanosecondes tout cela grâce au bout de code suivant:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

__asm__(".symver my_func_1_0,my_func@@LIBSIMPLE_1.0") int my_func_1_0(int x) {   printf("lib %s\n", __FUNCTION__) ;   return (x)   }   __asm__(".symver my_func_2_0,my_func@@LIBSIMPLE_2.0") int my_func_2_0(int x) {   printf("lib %s\n", __FUNCTION__) ;   return 100*(x)   }

---

En exportant comme symbole la fonction my_func(...).

Et donc suivant le numéro mineure de la bibliothèque la fonction my_func(...) retourne un résultat différents.

Bon rien d'anormale a cela en soit mais vous aurez sans doutes remarquez comment est écrit le code.

Par ailleurs l'auteur peut surcharger une fonction (En C) sans changer de numéro majeure une fonction grâce a une technique similaire.

Étonnant tout cela !

En passant un fichier de version au compilateur GNU:

Code:

---

1 2 3

gcc -Wall -g -O0 -fPIC -c simple.c gcc -shared simple.o -Wl,--version-script,my_script -o libsimple.so.1.0.0

---

Tout cela me laisse #pragmatique et je suis impatient d'entendre vos commentaires avisé.

Regardes le msdn :mrgreen: "Pragmas are machine- or operating system-specific by definition, and are usually different for every compiler."
Ou bien "A "pragma" instructs the compiler to perform a particular action at compile time.Pragmas vary from compiler to compiler."

Justement le #pragma once me semble un truc spécifique pour remplacer les fameux "code guards" (au début et à la fin de chaque fichier .h)

Code:

---

1 2 3 4 5 6

#ifndef XXXX_H #define XXXX_H   //...   #endif // XXXX_H

---

Et avec C++ Builder :mrgreen: tu es obligé de faire un #pragma link "XXX" pour ajouter une librairie à ton projet.
Tu as aussi #pragma resource "*.dfm" pour ajouter une/ des ressource(s) dans l'exécutable ou un truc spécifique #pragma package(smart_init)

Salut,

pas du tout un expert du sujet, je m'en sers comme tout le monde. A noter que le pragma once, s'il n'est pas standard est reconnu par à peu près tous les compilo. De mon côté j'utilise aussi les pragma pour des options de compilations/linkage. Pour une définition je dirais : une directive prépro qui fait des actions laissées au libre choix du compilo.

Pour le versionning j'ai jamais fait ça dans des mêmes fichiers (on a des gestionnaires de version qui font ça très bien).
Pour la compilation conditionnelle j'utilise de simples define.

Citation:

---

Envoyé par Luke spywoker

"Ceci n'est pas un poste d'un sujet méritant qu'on le classe dans la section débutant mais comme la section avancé n'existe pas je poste ici."

---

Il manque à dvp un smiley Facepalm. Tu aurais dû mettre ça dans la section C tout court...

Citation:

---

Envoyé par foetus

Et avec C++ Builder tu es obligé de faire un #pragma link "XXX" pour ajouter une librairie à ton projet.

---

L'équivalent Microsoft étant #pragma comment(lib, "XXX") (ou #pragma comment(linker, xxx) qui permet carrément de passer un paramètre sur la ligne de commande d'édition de liens).

Bonjour,
les directives pragma sont prévues par la norme pour informer le compilateur et modifier/tuner son comportement. La norme se réserve les #pragma STDC (cf section 6.10.6 de la norme C11). Si STDC est absent le compilateur est libre de les ignorer, de s'arrêter sur une erreur ou d'agir selon un comportement qui lui est propre.

#pragma once est supporté par de nombreux compilateurs mais a ses défauts propres, d'autant plus que ces mêmes compilateurs reconnaissent et optimisent les gardes d'inclusion.

Les #pragma sont aussi utilisé de manières propres par les compilateurs pour (listes non exhaustives)

• ajouter/enlever temporairement des options de compilations
• émettre des messages
• changer le comportement de l'éditeur de lien
• modifier la structure mémoire utilisée pour les structure
• ...

Il y en a une flopée que GCC reconnaît mais GCC utilise une autre méthode, celle des attributs qui est plus flexible.

Merci pour ces réponses éclairées et précises concernant ce sujet pragmatique :ptdr:

Alors donc la directive de préprocesseur #pragma permet d'accomplir certaines taches par le compilateur qui lui sont propres ou fonctionnant généralement.

Donc une directive #pragma est a utiliser en conjonction avec un compilateur précis afin d'atteindre un but précis lors de la compilation.

---

Je vous recommande chaudement le livre en question car même si l'on peut pas en tirer grands chose coté pratique,

la théorie est superbement écrite dans un anglais clair net et précis,

il suffit de suivre l'auteur pour le coté technique, évoquant parfois des corner-case un peu tirer par les cheveux mais toujours dans l'esprit didactique.

Je dirai que c'est un livre a lire simplement a but culturelle afin d'accumuler des connaissances.

J'ai commencé à feuilleter le livre … très intéressant.

Je pense que tu trouveras pas mal de choses intéressantes dans les papiers d'Ulrich Drepper, le tyran de la glibc → https://www.akkadia.org/drepper/