En-tete: #include ou class ?

Bonjour,

bien qu'ayant une certaine pratique du C++, certaines subtilités m'échappent encore parfois :aie:

Dans un fichiers ., j'ai ainsi la suite d'instructions:
Code:

1 2 3 4 5 #include "TObject.h" #include "TClonesArray.h" class TNT2Channel ;
Quelle difference y aurait-il à declarer

Code:

#include "TNT2Channel.h"

?

Est-ce au niveau de la compilation.

Merci d'avance pour les reponses :merci:

Bonjour et bienvenu sur le forum

La première version s'appelle une déclaration anticipée (forward declaration). Cela permet d'éviter justement d'inclure l'en-tête et donc de gagner en temps de compilation.
Voir aussi le problème des références croisées.

A utiliser quand ton fichier utilise des références ou des pointeurs vers ta classe.

Tu n'as qu'a penser comme ça : chaque #include ouvre un fichier, donc c'est lent. La déclaration anticipée est un moyen d'éviter cela quand on peut.

Salut,

Pour t'aider à comprendre, on peut dire les choses sous cet angle:

Le compilateur va lire les fichiers un peu à la manière dont tu lirais un livre : Tout comme tu ne connais, à la page dix du livre, que les 9 premières pages du livre, le compilateur ne connait, à une ligne donnée du code que ce qu'il a déjà rencontré dans les lignes qui précèdent.

Lorsque tu rencontre un nouveau personnage dans un livre, tu ne sais pas forcément tout de lui immédiatement, et tu apprendras à le connaitre au fil des pages, mais, dés qu'on te l'a présenté, tu "sais qu'il existe", et tu sais "de qui on parle" quand on parle de lui.

Pour le compilateur, c'est pareil : tant qu'il n'a pas besoin de réserver un espace mémoire particulier pour un objet d'un type donné ou d'appeler une fonction membre particulière de cet objet (c'est à dire : tant qu'il ne croise que des références ou des pointeurs sur cet objet, par exemple, en argument ou en retour de fonction), le simple fait de savoir que le type existe lui suffit.

Pour qu'il sache qu'un type existe, il suffit donc de faire ce que l'on appelle (comme l'ont indiqué les interventions précédentes) une déclaration anticipée.

C'est ce que l'on fait quand on ne fait suivre le mot clé class (ou struct) que du nom de la classe (ou de la structure):
Code:

1 2 3 4 5 class MaClass; // ceci est une déclaration anticipée. tant que tu n'essayera // pas de créer un objet de MaClass, ni d'en appeler une fonction // ca suffira: /* légal: on travaille sur des référence vers des objets "créés ailleurs" */ Maclass & void fooo(Maclass const & obj) ;
La directive préprocesseur #include "nom_de_fichier" va littéralement être remplacée par le contenu du fichier indiqué et ce de manière récursive.

Il s'agit réellement de recopier le contenu du fichier inclus et, s'il inclut lui même d'autre fichiers, d'en recopier le contenu à la place de la directive d'inclusion, et si, eux meme incluent d'autre fichier... (je pourrais continuer longtemps comme cela: les compilateurs qui respectent la norme doivent pouvoir inclure des fichiers sur au minimum 255 niveaux, de tête :P)

Dans un fichier d'en-tête, on va sans doute trouver (outre certaines inclusions de fichiers d'en-tête) plusieurs choses :

Des déclarations de fonctions (le prototype de la fonction, mais pas le code qu'elle contient) qui auront "simplement" pour but (tout comme la déclaration anticipée d'une classe) d'indiquer au compilateur que la dite fonction existe.
éventuellement des définitions de fonction inline (qu'elle le soient de manière implicite ou explicite) qui donneront "un corps" à la fonction (c'est ce que tu fais entre la paire d'accolade lorsque tu écris le corps de la fonction )
Le cas échéans, les déclarations anticipées pour certaines classes qui seraient utilisées comme argument ou comme retour de fonction,
Une (ou des) définition(s) de classe(s), qui aura comme but de "donner un corps" à la (ou aux) classe(s)
...
La définition de la classe va permettre au compilateur:
de savoir l'espace mémoire qui est utilisé par un objet de la classe en question (c'est, en gros, la somme de la taille de l'ensemble de ses membres ;), plus une ou deux choses qu'il n'est pas utile de citer ici :D ), et donc de placer une instance de la classe en mémoire
de savoir que telle ou telle fonction de la classe existe, et donc de vérifier si on l'appelle correctement (en comparant les objet qu'on lui passe en paramètre avec ceux que la fonction existe et en comparant ce que la fonction renvoie avec le type de l'objet qui est sensé le recevoir
En d'autres termes, la définition de la classe va donner "tout ce qu'il faut" au compilateur pour pouvoir l'utiliser ;)

Comme on te l'a si bien dit, l'inclusion d'un fichier d'en-tête prend énormément de temps (tu l'auras surement compris lorsque j'ai parlé d'inclusion réursive :D )

Le bon conseil que l'on pourrait donner est donc d'utiliser la déclaration anticipée "chaque fois que possible" et de n'inclure le fichier d'en-tête que lorsque l'on y est obligé (oserais-je aller jusqu'à écrire "que lorsque le compilateur le réclame :question: Oui, finalement, j'ose l'écrire :D )

Cette pratique a, entre autres, l'énorme avantage d'éviter les références croisées lorsqu'une classe servant de "contenant" doit connaitre son "contenu" et que le "contenu" doit garder une référence (un pointeur :question: ) vers son "contenant" un tour vers la FAQ te donnera un exemple de ce que j'explique ici ;))

Si mes explications t'ont permis de comprendre le principe, tu devrais dorénavant pouvoir déterminer assez facilement quand utiliser la déclaration anticipée et quand inclure le fichier :D