Version imprimable
salut à vous tous :
j'ai un programme en c++ et j'ai pas compri quelques instructions et j'ai meme cherché dans des cours mais je les ai pas trouvé, si quelqu'un peut me donner leur significations :
#include<vcl.h>
#pragma hdrstop
**__fastcall
il y a des instructions qui commencent par une ligne horizontale aussi????
merci d'avance.
Cette instruction demande au préprocesseur d'inclure le fichier d'en-tête vcl.h au début de ce fichier. Un tour dans la faq te donnera des détails (chercher inclure et fichiers d'en-tête).Citation:
Envoyé par dadou846
#pragma c'est du typique Visual C++ (vcl.h, hein...), je ne sais pas quelle est la pragma hdrstop (fin d'inclusion de header, ou quelque chose comme ça peut-être).Citation:
Envoyé par dadou846
Là on entre dans les finesses des instructions assembleur, me semble-t-il, et je suis totalement incapable de te renseigner :aie: .Citation:
Envoyé par dadou846
Salut, et bienvenue sur le forum.
La directive #include "quelque_chose" ou #include <quelque_chose" est une instruction préprocesseur qui a pour but de faire connaitre au compilateur quelque chose qui est déclaré dans le "quelque_chose" et qui est nécessaire pour traiter le code en cours.
Le préprocesseur va remplacer cette directive par le contenu du fichier donné entre guillemet ou entre chevrons.
L'inclusion du fichier <vcl.h> a donc pour but de demander au préprocesseur d'insérer le contenu du fichier vcl.h, qui est un fichier d'en-tête nécessaire pour que le compilateur connaisse la bibliothèque graphique que tu utilise (la bibliothèque graphique "made in borland" ;))
La directive #pragma a pour objectif de demander au compilateur de faire (ou de ne pas faire) certaines choses, mais est très dépendante du compilateur utilisé, sauf erreur #pragma hdrstop a pour but de demander au compilateur d'utiliser ce que l'on appelle des en-tête précompilés, afin de minimiser le temps de compilation.
Pour le ** __fastcall, il manque sans doute ce qui se trouve à la ligne d'avant, et ce qui se trouve à la ligne d'après, mais, en gros:
les deux étoiles "**" indiquent que ce qui sera renvoyé sous la forme d'un pointeur de pointeur et la ligne d'après devrait fournir le nom d'une fonction ou d'une méthode d'une classe particulière.
Le terme __fastcall spécifie une convention d'appel qui, sauf erreur, indique que les différents paramètres doivent être placés dans un registre, autant que faire se peut.
Tu trouvera d'autres informations sur hdrstop et sur fastcall sur le site de la msdn de microsoft ;)
Sauf qu'en fait, ce n'est pas du Visual mais du Borland.
- Il n'y a pas de vcl.h sous Visual, il s'agit de la Visual Component Library de Borland.
- #pragma hdrstop n'est pratiquement jamais utilisé sous Visual, et n'est présent dans aucun modèle de fichier
- __fastcall n'est pratiquement jamais utilisé non plus, alors que Borland l'utilise systématiquement pour ses événements;
Bonjour et bienvenu,
Sans que cela soit obligatoire, le code est souvent scindé en deux partie : la déclaration et la définition. La déclaration sert juste à indiquer au compilateur ce qui existe: de quoi est constituée une classe, quelles sont les fonctions, quels sont les types etc... La définition contient le code qui réalise ce qui a été précédemment défini.
On sépare les deux parties de façon suivante:
-> Les fichiers d'en-tête contiennent habituellement les déclarations. Ce sont des fichiers qui se terminent par l'extension .h ou .hpp.
-> Les fichiers sources se sont ceux qui contiennent les définitions. Ce sont les .cpp.
Les fichiers sources comme les fichiers d'en-têtes incluent d'autres fichiers d'en-têtes quand ils ont besoin de connaître les définitions des autres modules.
Ici on indique qu'on inclue le fichier de déclaration vcl.h. Il s'agit, je crois, d'un fichier spécifique au compilateur borland.Citation:
Envoyé par dadou846
Générer un projet (un exécutable, un librairie...) se déroule en plusieurs phases :
1/ Chaque fichier de définition (les .c) est compilé pour donner du code objet. Ce sont en général des fichiers .o ou .obj; fichiers binaires qui contiennent du code et sont illisibles pour un personne bien formée :mrgreen:
2/ Les différents fichiers objets sont liés (ou linker) pour donner l'exécutable (ou la librairie...).
La première phase, la compilation, se découpe elle aussi en 2 parties :
1/ Le pre-processing : c'est une phase où aucun code n'est généré mais où on donne des indications pour le compilateur. Par exemple, c'est dans cette phase que sont traités les #define, les #includes, etc... Schématiquement, on peut dire que cette phase prend en entrée un fichier et donne en sortie le même fichier dans lequel des opérations ont été effectuées:
-> les #include "en-tete.h" font qu'on recopie à la place de cette instruction tout ce qui a dans en-tete.h
-> Les #define TUTU machin font que partout où on trouve TUTU, on le remplace par machin
-> Les #pragma sont des directives qui donnent des instructions au pré-processeur.
2/ La compilation : on utilise le fichier produit par la phase précédente pour générer le code exécutable.
Il s'agit d'une directive du pré-processeur. Ces directives sont spécifiques aux compilateurs. Celle-ci concerne la gestion des en-têtes précompilés il me semble et pour un débutant, je dirais que pour l'instant ce n'est pas important.Citation:
Envoyé par dadou846
Je doute que ce soit la ligne entière de ton code.Citation:
Envoyé par dadou846
__fastcall est un mot clé spécifique du compilateur Visual C++. Pour un débutant, je dirais que pour l'instant, il vaut mieux ne pas t'en soucier.
Pour revenir à ta question initiale : oui des instructions peuvent commencer par '_' ou par '__' (2x '_'). La réponse est oui. Cependant, il n'est pas recommander de déclarer ses propres identifiants en débutant avec le caractère souligné. Ils sont en général réservés par les compilateurs pour les extensions qu'ils proposent.Citation:
Envoyé par dadou846
J'espère que ces premiers éléments vont te permettre de continuer à avancer.
P.S. : tout vient à point à qui sait attendre ;)
merci à vous tous, ça va bien m'aider.
a+