Ordre de compilation des fichiers

Bonjour,

Je travaille sur un projet qui comporte plusieurs fichiers.
Lorsque je compile le projet, la compilation commence par le dernier fichier ajouté au projet ce qui me cré des erreurs.
Comment faire pour forcer la compilation en premier sur le fichier principal du projet afin que les fichiers soient traités dans l'ordre de leur inclusion par la commande #include?
Par ailleurs que pensez vous de placer les variables globales dans un fichier séparé?
Y a til des différences de traitements entre les fichiers .cpp et .h, car pour ces derniers, on peut utiliser les directives #if defined, peut on aussi les utliser pour des fichiers .cpp qui contiennent des classes et leur fonctions?

Salut,

Il faut être très attentif à ce qu'on met dans quel fichier:

Un fichier *.h est un fichier d'en-tête: il sert à contenir

• les définitions de classe (le fait de dire à quoi elles ressemblent: type et nom des membres, prototype des fonction membre),
• la déclaration des fonctions libres (le fait de fournir le prototype des fonctions: leur "signature", sans fournir la logique à suivre)
• la déclaration des variables globales (le fait de dire que telle variable existe et qu'elle est de tel type)

Les fichier *.cpp sont des fichiers d'implémentation: ils contiennent

• l'initialisation des variables globales
• la définition des fonctions libres (le fait de fournir la suite logique des instructions que doit effectuer la fonction)
• la définition des fonctions membres

On ne le répétera jamais assez, les variable globales, c'est mal... je tiens les explication là dessus "au chaud" si tu veux savoir pourquoi :roll:

Il n'y a que les fichiers d'en-tête qui doivent (puissent :P) être inclus dans d'autre fichiers: le compilateur travaille comme le lecteur d'un livre: de haut en bas... Quand on est à la page 8 d'un livre, on sait tout ce qui s'est passé dans les 7 premières pages, mais on ignore tout de ce qui se passe en page 10 (du moins, si c'est la première fois qu'on lit le livre :roll:)

Pour qu'il sache provoquer l'appel d'une fonction, il faut juste qu'il connaisse le prototype de cette fonction (le type de valeur qu'elle renvoie, son nom et les paramètres qu'elle accepte), autrement dit: il doit disposer du fichier d'en-tête dans lequel la fonction (ou la fonction membre) est déclarée...

Il est à noter que si tu inclus le fichier A.h dans un fichier d'implémentation, et que A.h inclus le fichier B.h qui, lui-même inclus le fichier C.h (qui lui-même inclus...) le fichier d'implémentation saura que, non seulement, tout ce qui est déclaré dans A.h existe, mais aussi tout ce qui est déclaré dans B.h, dans C.h etc.: on peut réellement parler d'inclusion en cascade sur ce coup là :D

Si tu respecte les règles, l'ordre de compilation ne pose aucun problème: tous les fichiers sont compilés séparément, puis c'est le rôle de l'éditeur de liens que de faire pointer les appels de fonctions aux bons endroits ;)

La suite, vers 23h00, si tu a d'autres questions (j'ai un train à prendre, là :P)