Discussion :

[tabkelm]

bonjour,

après #include on met un nom comme cela:
-<nom.h>
ou
-"nom.h"

1)quand c'est entre <>,s'agit-il d'une classe,d'une librairie ou d'une bibliothèque?
oui la librairie est une partie de la bibliothèque

2)quand c'est entre "",s'agit-il d'une classe,d'une librairie ou d'une bibliothèque?

3)quand j'ai crée une classe dans son header class.h avec ces prototypes,afin d'implémenter ces prototypes dans un fichier .cpp,
je commence ce dernier par:
#include "class.h" ?
ou
#include <class.h> ?

4)le header d'une classe contient-t-il la déclaration de ses objets?

merci de votre aide

[chrtophe]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#include <nom.h>

va chercher le fichier dans le chemin d'en-tête par défaut, il s'agit des en-têtes prédéfinis.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#include "nom.h"

va chercher le fichier dans le dossier en cours ou celui indiqué dans le nom comme #include "/home/test/mon_header.h"Donc si c'est quelque chose que tu as créé toi c'est entre guillemets.

[dalfab]

Bonjour,

1) Les <> sont plutôt pour les bibliothèques externes (des répertoires définis globalement)
2) Les "" sont plutôt pour les données de ton application (le même répertoire que le source, et des répertoires d'includes locaux)
La différence entre les 2, correspond à dans quels répertoires chercher le fichier.
3) #include "class.h"
4) n'as-tu pas voulu écrire "ses objets" plutôt que "ces objets"? Ça change complètement la question.
Pour "ses objets":
un include pour une classe doit définir la classe, et donc ses constituants sont obligatoirement à minima déclarés, mais certains doivent en plus être définis:
* sous-types (définition incomplète possible)
* alias de types
* données si non statiques ou inline
* fonctions membres si inline
* template de fonction, de classe, d'alias de type ou de données. Non obligatoire, mais définition fortement conseillée dans l'entête.

Et on retrouvera dans le fichier source, les définitions des autres constituants:
* définition des sous-types restés incomplets dans l'entête, et de leurs composants.
* définition des données à la fois statique et non inline
* fonctions membres non inline

Pour "ces objets":
Les includes à utiliser dans un entête sont :
* ceux véritablement nécessaires à l'entête lui-même.
* on ne met pas ceux que l'objet nécessite en interne. Par exemple, l'objet utilise <iostream> mais rien de visible dans l'entête, surtout pas d'include<iostream>.
* on ne met pas les includes des objets qui ne sont vus qu'en pointeur ou référence dans l'entête. A la place, on met une définition incomplète.

[tabkelm]

4)oui corrigé maintenant c'était ses objets.
D'après la réponse précédente,le header d'une classe ne contient pas ses objets ?

[dalfab]

un include pour une classe doit définir la classe, et donc ses constituants sont obligatoirement à minima déclarés, mais certains doivent en plus être définis

Si par objet tu penses à des objets de instanciés de ta classe, ceci n'est à mettre nulle part car, ça n'a normalement aucune raison d'exister. Donnes un exemple.

[koala01]

Salut,

4)oui corrigé maintenant c'était ses objets.
D'après la réponse précédente,le header d'une classe ne contient pas ses objets ?

On va faire simple: un fichier d'en-tête permet uniquement de savoir que "quelque chose existe". Par exemple:

1. Pour une fonction, cela va lui permetre de savoir qu'il existe une fonction nommée foo qui prend tel et tel paramtère de tel type et qui renvoie (éventuellement) une valeur de tel type
2. Pour une énumération : cela va lui permettre de savoir qu'il existe une énumération nommée MyEnum et qu'elle contient les valeurs énumérées Valeur1, Valeur2, ... , ValeurN
3. Pour un agrégat de donnée: cela va lui permettre de savoir qu'il existe une "structure" nommée MyStruct et qu'elle est composée de telle et telle donnée (le type et l'identifiant qui permet d'y accéder)
4. Pour une classe : cela va lui permettre de savoir qu'il existe une classe MyClass (qui hérite éventuellement de la classe Base et qui pourra donc être transmise à toute fonction s'attendant à recevoir un objet de type Base comme paramètre) qui dispose telle et telle fonction (identifiant, paramètre requis, valeur éventuellement renvoyée) dans telle ou telle visibilité, et de telles et telles données qui permettront au fonctions de faire leur travail.

Pour les agrégats de données et les classes, le fichier d'en-tête permet également au compilateur de savoir combien de bytes il doit prévoir d'espace afin de pouvoir les représenter dans le programme (et, accessoirement, de savoir de combien de bytes il doit se décaller pour pouvoir modifier la valeur d'une des données qui les composent).

Grâce à cela, lorsqu'il rencontre l'identifiant d'une fonction, d'une énumération, d'une structure ou d'une classe dans la fonction qu'il traite, il est en mesure de vérifier que "tout est en ordre" et qu'on utilise cet identifiant de manière correcte. Par exemple:

• que l'on transmet des arguments de type adéquat à la fonction, en nombre suffisant (mais pas excessif) et que l'on récupère (éventuellement) la valeur renvoyée dans un donnée du type adéquat.
• que l'on n'utilise que les identifiants correspondant aux valeurs énumérées contenues dans l'énumération indiquée (et, le cas échéant, que toutes les valeurs énumérées ont été prises en compte)
• que l'on essaye d'accéder aux données qui composent une structure (ou une classe) au travers du nom correct de ces données et, accessoirement, qu'on les utilise de manière correcte.
• ....

Car le compilateur est exactement dans la même situaiton que toi quand tu lis un livre: quand tu es à la page 10 du livre, tu ne sais que ce qui s'est passé dans les neuf premières pages, et tu n'as absolument aucune idée de ce qui se passe à la page 12.

Hé bien, tu dois te dire que, quand le compilateur est occupé à traiter le ligne 10 de ton code, il ne connait du code que ce qu'il a rencontré en traitant les 9 premières lignes, et qu'il n'a aucune idée de ce qui se passe à la ligne 12.

Et comme le compilateur est un emmerdeur fini, qui n'accepte de travailler qu'avec des choses qu'il connait, il faut bien "trouver le moyen" de lui faire connaître les fonctions auxquelles tu veux faire appel ainsi que les types de données que tu veux utiliser.

Les fichiers d'en-tête permettent d'éviter de devoir recopier -- au début de chaque fichier d'implémentation -- tous les éléments que le compilateur doit connaitre pour qu'il soit content et qu'il accepte de travailler.

Il suffit en effet d'une directive #include -- que le préprocesseur remplacera par le contenu intégral du fichier concerné -- pour que le compilateur sache "tout ce qu'il doit savoir" sur... tout ce qui se trouve dans le fichier en question