IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage C++ Discussion :

En-tete: #include ou class ?


Sujet :

Langage C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Candidat au Club
    Profil pro
    Inscrit en
    Mars 2009
    Messages
    2
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2009
    Messages : 2
    Par défaut En-tete: #include ou class ?
    Bonjour,

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

    Dans un fichiers ., j'ai ainsi la suite d'instructions:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    #include "TObject.h" 
    #include "TClonesArray.h"
     
    class TNT2Channel ;
    Quelle difference y aurait-il à declarer
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    #include "TNT2Channel.h"
    ?

    Est-ce au niveau de la compilation.

    Merci d'avance pour les reponses

  2. #2
    Inactif  


    Homme Profil pro
    Inscrit en
    Novembre 2008
    Messages
    5 288
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Secteur : Santé

    Informations forums :
    Inscription : Novembre 2008
    Messages : 5 288
    Par défaut
    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.

  3. #3
    Membre éprouvé
    Profil pro
    Inscrit en
    Novembre 2004
    Messages
    2 766
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2004
    Messages : 2 766
    Par défaut
    A utiliser quand ton fichier utilise des références ou des pointeurs vers ta classe.

  4. #4
    Membre Expert
    Avatar de Klaim
    Homme Profil pro
    Développeur de jeux vidéo
    Inscrit en
    Août 2004
    Messages
    1 717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur de jeux vidéo
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 1 717
    Par défaut
    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.

  5. #5
    Expert éminent
    Avatar de koala01
    Homme Profil pro
    aucun
    Inscrit en
    Octobre 2004
    Messages
    11 644
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : Belgique

    Informations professionnelles :
    Activité : aucun

    Informations forums :
    Inscription : Octobre 2004
    Messages : 11 644
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 )

    Dans un fichier d'en-tête, on va sans doute trouver (outre certaines inclusions de fichiers d'en-tête) plusieurs choses :
    1. 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.
    2. é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 )
    3. Le cas échéans, les déclarations anticipées pour certaines classes qui seraient utilisées comme argument ou comme retour de fonction,
    4. Une (ou des) définition(s) de classe(s), qui aura comme but de "donner un corps" à la (ou aux) classe(s)
    5. ...
    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 ), 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 )

    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 Oui, finalement, j'ose l'écrire )

    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 ) 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
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

Discussions similaires

  1. [PHP 5.3] Probleme d'include de class
    Par thebarbarius dans le forum Langage
    Réponses: 4
    Dernier message: 04/03/2010, 06h05
  2. pb fichier include pour classes dérivées
    Par Bapte59 dans le forum C++
    Réponses: 1
    Dernier message: 04/03/2009, 09h03
  3. [POO] [Alias] Problème d'include avec classe
    Par scorpiwolf dans le forum Langage
    Réponses: 3
    Dernier message: 05/06/2006, 20h55
  4. Include et class, avec 3 classes
    Par Captain_JS dans le forum C++
    Réponses: 2
    Dernier message: 26/02/2006, 17h50
  5. Réponses: 5
    Dernier message: 07/02/2006, 11h12

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo