#inclure est un moyen d'inclure un fichier standard ou défini par l'utilisateur dans le programme et est principalement écrit au début de tout programme C. La directive du préprocesseur #include est lue par le préprocesseur et lui demande d'insérer le contenu d'un fichier d'en-tête défini par l'utilisateur ou système dans notre programme C. Ces fichiers sont principalement importés depuis des fichiers d'en-tête externes.
Le processus d'importation de tels fichiers qui peuvent être définis par le système ou par l'utilisateur est connu sous le nom de Inclusion de fichiers . Cette directive du préprocesseur indique au compilateur d'inclure un fichier dans le programme de code source.
Types de fichiers d'en-tête
Il existe deux types de fichiers qui peuvent être inclus à l'aide de #include :
1. Fichiers d'en-tête préexistants : Les fichiers d'en-tête préexistants sont fournis avec le compilateur et résident dans le répertoire de fichiers système standard. Ce fichier contient des déclarations de fonctions de bibliothèque standard C et des définitions de macros à partager entre plusieurs fichiers sources. Des fonctions telles que printf(), scanf(), cout, cin et diverses autres fonctions d'entrée-sortie ou d'autres fonctions standard sont contenues dans différents fichiers d'en-tête préexistants.
2. Fichiers d'en-tête définis par l'utilisateur : Ces fichiers ressemblent aux fichiers d'en-tête, à la différence près qu'ils sont écrits et définis par l'utilisateur lui-même. Cela évite à l'utilisateur d'écrire plusieurs fois une fonction particulière.
Syntaxe de #include en C
Il existe deux variantes de la façon dont nous pouvons utiliser #include dans notre programme C.
1. Y compris l'utilisation
Il est principalement utilisé pour accéder fichiers d'en-tête système préexistants situé dans les répertoires système standard.
#include>
Lors de l'importation d'un fichier à l'aide de crochets angulaires (), le préprocesseur utilise un chemin de répertoire prédéterminé pour accéder au fichier.
2. Y compris l'utilisation
Ce type est principalement utilisé pour accéder aux fichiers d'en-tête du programme de l’utilisateur ou fichiers définis par l’utilisateur.
#include 'user-defined_file'>
Lors de l'utilisation des guillemets doubles ( ), le préprocesseur accède au répertoire courant dans lequel se trouve le fichier d'en-tête source ou aux répertoires système standard.
Pour importer le fichier d'en-tête défini par l'utilisateur à l'aide de #include, le fichier doit se trouver dans un chemin de répertoire relatif à votre fichier source C, sinon le préprocesseur commencera à le rechercher dans le répertoire système standard.
Pour en savoir plus, référez-vous à Différence entre #include et #include
Exemples de #include en C
Exemple 1
Le code ci-dessous montre l'importation d'un en-tête d'E/S système ou d'un fichier standard.
C
types de réseau
// C program showing the header file including> // standard input-output header file> #include> int> main()> {> >// 'printf()' belongs to stdio.h> >printf>(>'hello world'>);> >return> 0;> }> |
>
>Sortir
hello world>
Exemple 2
Dans l'exemple ci-dessous, le#include>La directive nous permet d'utiliser des fonctions mathématiques commesqrt>pour calculer la racine carrée.
C
np zéros
// C program to calculate square root of a number using the> // math library functions> #include // Including math header for mathematical operations> #include> int> main()> {> >double> num = 14.0;> >double> Res =>sqrt>(num);> >printf>(>'Square root of %.2f is %.2f
'>, num, Res);> >return> 0;> }> |
>
>Sortir
Square root of 14.00 is 3.74>
Exemple 3
Le code ci-dessous montre la création et l'importation d'un fichier défini par l'utilisateur.
Création d'un en-tête défini par l'utilisateur sous le nom de process.h.
C
// It is not recommended to put function definitions> // in a header file. Ideally there should be only> // function declarations. Purpose of this code is> // to only demonstrate working of header files.> void> add(>int> a,>int> b)> {> >printf>(>'Added value=%d
'>, a + b);> }> void> multiply(>int> a,>int> b)> {> >printf>(>'Multiplied value=%d
'>, a * b);> }> |
>
>
mise en gras en CSS
Création du fichier principal où le process.h ci-dessus sera inclus.
C
// C program to illustrate file inclusion> // used to import system header file> #include> // ' ' used to import user-defined file> #include 'process.h'> // main function> int> main()> {> >// add function defined in process.h> >add(10, 20);> >// multiply function defined in process.h> >multiply(10, 20);> >// printf defined in stdio.h> >printf>(>'Process completed'>);> >return> 0;> }> |
>
>
Explication
Inclure le fichier process.h dans un autre programme. Maintenant que nous devons inclure stdio.h comme #include afin d'utiliser la fonction printf() de la même manière, nous devons également inclure le fichier d'en-tête process.h comme #include process.h. Le demande au préprocesseur d'examiner le dossier actuel ou le dossier standard de tous les fichiers d'en-tête, s'il n'est pas trouvé dans le dossier actuel.
Si des crochets angulaires sont utilisés à la place, le compilateur recherchera le fichier d'en-tête dans le dossier standard des fichiers d'en-tête. Si vous utilisez, vous devez vous assurer que le fichier d'en-tête créé est enregistré dans le même dossier dans lequel le fichier C actuel utilisant ce fichier d'en-tête est enregistré.
Conclusion
En programmation C, la directive #include est très importante pour intégrer tous fichiers externes (fichiers d'en-tête) dans un programme. Cette directive est toujours placée au début d'un programme C et c'est une commande de préprocesseur qui indique au compilateur d'inclure le contenu du fichier spécifié après la directive #include. Deux types de fichiers peuvent être inclus : les fichiers d'en-tête système préexistants et les fichiers d'en-tête définis par l'utilisateur. Globalement, cette directive nous permet d'écrire un code modulaire, d'organiser le code et des fonctionnalités faciles à réutiliser.