INF155 – COURS 06
La Directive « #if .. #endif »,
Les Tableaux et les Pointeurs,
Les Tableaux à Deux Dimensions,
Et Les Fichiers Textes.
Eric Thé
Service des Enseignements Généraux
École de Technologie Supérieure
Automne 2025
6.1 La Directive de Pré-Compilation #if..#endif :
Gestion d’un « projet » avec Visual C++ :
1- Dans le gestionnaire de projet (fenêtre verticale à la gauche), aller sur la page nommée « File
View ». En appuyant sur le carré avec un « + » on obtient 3 catégories de fichiers.
2- Cliquez à droite (right-click) sur « Source Files » et faites « Add Files to Folder.. » pour y ajouter
les fichiers-sources « *.c » (ou « *.cpp »). ATTENTION : NE JAMAIS MÉLANGER des
fichiers « *.c » avec des fichiers « *.cpp » dans un même projet !
3- Faites la même chose sur « Header Files » pour y ajouter vos fichiers d’en-têtes « *.h ».
Dans certaines configurations de « projets » il se peut qu’un fichier d’en-tête (*.h) soit compilé
deux fois à travers la compilation de deux librairies (*.cpp) différentes. Ceci entraine des erreurs
de compilation du genre « multiple declaration of … » (traduction : « déclaration multiple de … »).
Ce scénario de compilation « en double » est presque inévitable lorsque plusieurs librairies ont
besoin des mêmes définitions de types pour pouvoir compiler séparément.
La directive de pré-compilation #if permettra d’empêcher la double compilation d’un fichier ou
d’une partie d’un fichier dans un projet. En voici un exemple simple :
PROJET : « BRASSE3 »
Dans ce projet, le fichier d’en-tête « CARTELB2.h » sera compilé avec le #include du fichier
« [Link] » et aussi avec le #include du fichier « [Link] ».
Donc, la compilation du fichier principal « [Link] » entrainera une double compilation du
type énuméré « couleur » et du prototype de la fonction « brasseur ». On doit encadrer ces
déclarations avec un #if .. #endif pour empêcher la double compilation.
Voici le fichier principal “[Link]” :
[Link]
#include "cartelb2.h" //ici ces 2 "include" vont créer une compilation double
#include "affichag.h" //du typedef "t_couleur" ET la constante "NB_CARTE"!!
void main(void)
{ int rang[NB_CARTES]; //tableaux des valeurs et des couleurs
t_couleur sorte[NB_CARTES];
int c, i, j;
srand(time(NULL));
i = 0;
for (j=0; j<13; j++) {
for (c = PIQUE; c <= CARREAU; c++) {
rang[i] = j;
sorte[i] = (t_couleur) c;
i++;
}
}
system("cls"); printf("Avant de brasser\n\n");
affiche(rang, sorte);
brasseur(rang, sorte);
system("cls"); printf("Après avoir brassé\n\n");
affiche(rang, sorte);
}
1
CARTELB2.h AFFICHAG.h
#define _CRT_SECURE_NO_WARNINGS #include "cartelb2.h"
#include <stdio.h>
#include <stdlib.h> void affiche(const int *, const t_couleur *);
#include <time.h>
#if !defined( OK_CARTELB2 ) [Link]
#define OK_CARTELB2 1 #include "affichag.h"
#define NB_CARTES 52 void affiche(const int *rang,
const t_couleur *sorte)
typedef enum {PIQUE, COEUR, TREFLE, CARREAU} { int i,
t_couleur; x;
void brasseur(int *, t_couleur *); for (i=0; i < NB_CARTES; i++) {
x = rang[i];
#endif switch (sorte[i]) {
case PIQUE : printf("%8d Pique ", x+1);
break;
[Link] case COEUR : printf("%8d Coeur ", x+1);
#include "cartelb2.h" break;
//fonction PRIVÉE (static) case TREFLE : printf("%8d Trefle ", x+1);
static int alea(int min, int max) break;
{ return (rand() % (max - min + 1) + min); } case CARREAU: printf("%8d Carreau", x+1);
void brasseur(int *rang, t_couleur *sorte) }
{ int paquet[NB_CARTES] = {0}, if ((i+1)%4 == 0) printf("\n");
i, x, y, z; }
for (i=0; i < NB_CARTES; i++) { system("pause");
do { x = alea(0, 12); }
y = alea(PIQUE, CARREAU);
z = y*13 + x;
} while (paquet[z]);
paquet[z] = 1;
rang[i] = x;
sorte[i] = (t_couleur) y;
}
}
La directive : #pragma once
Depuis VS2019 cette nouvelle directive remplace et fait le même travail que l’utilisation d’un :
#if … #endif
CARTELB2.h
#pragma once Indique que ce fichier sera compilé qu’une seule fois
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define NB_CARTES 52
typedef enum {PIQUE, COEUR, TREFLE, CARREAU} t_couleur;
void brasseur(int *, t_couleur *);
2
6.2 Retour sur les Pointeurs :
Une variable de type pointeur contient une adresse. Pour être utilisée dans votre programme,
l’adresse d’une autre variable doit être assignée à un pointeur du même type. Donc, pour un type
quelconque T, un pointeur de type « T * » est apte à conserver l’adresse d’une variable dont le
contenu est aussi de type T. Ainsi, avec une variable et un pointeur ;
T valeur, *ptr = &valeur; (où T est autre chose que void)
*ptr donnera accès au contenu de la variable pointée par ptr.
Lorsqu’un pointeur est déclaré, celui-ci n’est pas initialisé automatiquement à une adresse valide.
L’utilisation d’un pointeur non initialisé est une erreur grave et malheureusement fréquente en C. Le
compilateur ne prend aucune responsabilité sur l’utilisation du contenu d’un pointeur. Pour aider le
programmeur, la norme ANSI offre le symbole NULL – équivalent à l’adresse # 0 – assignable à tout
type de pointeur pour indiquer qu’il n’adresse rien (donc, n’est pas initialisé).
Eg. T *ptr = NULL;
L’arithmétique des pointeurs
Les opérations permises sur une adresse ou un pointeur tiennent compte de la taille de son contenu.
Ainsi, on ne pourra pas effectuer d’opérations arithmétiques sur des adresses génériques (void *).
Mais pour tous les autres types standards ;
1. La somme d’une adresse et d’un entier donne une adresse :
Avec un pointeur ptr de type « T * » et un entier positif n, la somme (ptr + n) donnera une
autre adresse de type « T * » et cette nouvelle position est décalée de +(n*sizeof(T))
octets dans la mémoire par rapport à la position de départ ptr.
Eg. Avec : double tab[10], *ptr = tab;
int n = 2;
l’adresse (ptr + n) sera 2 * 8 = 16 octets plus loin dans le tableau tab. Donc, l’adresse donnée
par (ptr + n) équivaut au décalage donné par tab[n].
2. La différence d’une adresse et d’un entier donne une adresse :
Avec un pointeur ptr de type « T * » et un entier positif n, la différence (ptr - n) donnera
une autre adresse de type « T * » et cette nouvelle position est décalée à gauche de -
(n*sizeof(T)) octets dans la mémoire par rapport à la position de départ ptr.
3. La différence de deux adresses du même type « T * » donne un entier :
Avec deux pointeurs ptr1 et ptr2 de type « T * », la différence (ptr1 - ptr2)
correspond au nombre d’objets de type T entre ces deux adresses.
ATTENTION : L’utilisation de l’arithmétique des pointeurs n’a de sens que sur des adresses à
l’intérieur d’un même tableau. De plus, le compilateur ne prend aucune responsabilité en rapport aux
débordements qui puissent arriver quand un décalage de pointeur dépassera les limites déclarées de
ce tableau.
3
6.3 Relation entre les Tableaux et les Pointeurs :
En C, le nom d’un tableau sans la spécification d’un indice-position (eg. tab au lieu de tab[0])
représente l’adresse de la première case de ce tableau. Donc, tab est en fait un pointeur à
l’élément tab[0].
Exemples : Soit les déclarations suivantes : int tab[100], *p, x;
Ex. 1 : les deux affections ; p = &tab[0]; et p = tab; sont équivalentes.
Ex. 2 : même chose pour ; p = &tab[1]; et p = tab + 1;
p = &tab[x]; et p = tab + x; //avec int x;
Ex. 3 : exemple d’une somme des éléments de tab[] avec un pointeur ;
int somme_tableau(int * tab, int taille) {
int somme = 0;
int * p; //pointeur sur les éléments du tableau
for ( p = tab; p < &tab[taille]; ++p )
somme += *p;
return somme;
}
Ex. 4 : voir la fonction « differents() » du programme TABLO.c (Cours05)
ATTENTION : Le nom d'un tableau statique est une adresse inamovible, ce n'est donc pas une
Lvalue valide. Vous ne le verrez jamais à gauche d'une assignation.
Donc, les affectations suivantes : tab = p; ++tab; tab += x;
..sont toutes non-valides!!
6.4 Comment Trouver une Valeur dans un Tableau :
[Link] : Les Fouilles sur Tableaux (2 algorithmes)
/* Programme qui compare les algorithmes de fouilles linéaire vs. binaire. */
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/* Fonction qui renvoie la position de "y" dans le tableau "tab" de taille "n".
Si la valeur n'est pas présente dans le tableau, la fonction renvoie -1. */
int lineaire (int , int *, int); //notez que (int *) est pareil à (int [])
/* Fonction qui renvoie la position de "y" dans le tableau "tab" de taille "n".
Si la valeur n'est pas présente dans le tableau, la fonction renvoie -1.
Cette fonction utilise l'algorithme de fouille binaire (dichotomique).
IMPORTANT: les valeurs du tableau doivent déjà être en ordre croissant. */
int binaire (int , int *, int);
void main(void)
{ int tab[10] = {1,2,4,5,6,9,11,13,16,20};
4
printf("Fouille LINEAIRE\n\n");
printf("%3d est a la position %3d \n", 13, lineaire(13, tab, 10));
printf("%3d est a la position %3d \n", 1, lineaire( 1, tab, 10));
printf("%3d est a la position %3d \n", 5, lineaire( 5, tab, 10));
printf("%3d est a la position %3d \n", 8, lineaire( 8, tab, 10));
printf("\n\nFouille BINAIRE\n\n");
printf("%3d est a la position %3d \n", 13, binaire(13, tab, 10));
printf("%3d est a la position %3d \n", 1, binaire( 1, tab, 10));
printf("%3d est a la position %3d \n", 5, binaire( 5, tab, 10));
printf("%3d est a la position %3d \n", 8, binaire( 8, tab, 10));
}
int lineaire(int y, int tab[], int n)
{ int i=0, trouve=0;
while(i<n && !trouve) {
if (tab[i] == y) trouve = 1;
else i++;
}
if (trouve) return i;
else return -1; //la valeur n'a pas été trouvée!
}
int binaire(int y, int tab[], int n) //fouille dichotomique!
{ int m=n/2, trouve=0, debut=0, fin=n-1;
while(!trouve && m>=debut && m<=fin && debut<=fin) {
if (tab[m] == y) trouve = 1;
else if (y < tab[m]) fin = m-1; //on va chercher à GAUCHE du milieu
else if (y > tab[m]) debut = m+1; //on va chercher à DROITE du milieu
if (!trouve)
m = (debut+fin)/2; //calculer la nouvelle position du milieu
}
if (trouve) return m;
else return -1; //la valeur n'a pas été trouvée!
}
6.5 Les Tableaux à 2-Dimensions :
On peut déclarer un « tableau de tableaux » ou une matrice à 2-dimensions (avec rangées et
colonnes) avec une déclaration comme la suivante :
int tab[3][5];
nombre de colonnes
nombre de rangées
Voici la représentation visuelle de la matrice « tab » :
colonne 0 colonne 1 colonne 2 colonne 3 colonne 4
rangée 0 tab[0][0] tab[0][1] tab[0][2] tab[0][3] tab[0][4]
rangée 1 tab[1][0] tab[1][1] tab[1][2] tab[1][3] tab[1][4]
rangée 2 tab[2][0] tab[2][1] tab[2][2] tab[2][3] tab[2][4]
5
Exemple de manipulation de la matrice « tab » :
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#define M 3 //nb. de rangées
#define N 5 //nb. de colonnes
void main()
{ int tab[M][N], i, j, somme=0;
//remplir la matrice
for (i=0; i < M; ++i) //pour chaque ligne..
for (j=0; j < N; ++j) //pour chaque colonne..
tab[i][j] = i+j; //on inscrit la somme des indices
//afficher la matrice
for (i=0; i < M; ++i) { //pour chaque ligne..
for (j=0; j < N; ++j) //pour chaque colonne..
printf("tab[%d][%d] = %d ", i, j, tab[i][j]);
printf("\n");
}
//EXERCICE: faire la somme des éléments de “tab”
for (i=0; i < M; ++i) //pour chaque ligne..
for (j=0; j < N; ++j) //pour chaque colonne..
somme += tab[i][j];
printf("\nSomme = %d\n", somme);
}
Passage de Tableaux à 2-Dimensions en Paramètre :
Quand on déclare une fonction qui reçoit un tableau à plusieurs dimensions comme paramètre, toutes
les dimensions sauf la première doivent être spécifiées explicitement.
Eg. int somme_tab(int tab[][N], int m, int n); //tableau m x n
Eg. Cette fois-ci avec un tableau à 3 dimensions (tableau m x n x o) !
int somme_tab(int tab[][N][O], int m, int n, int o);
LABO_6, Exercice #1
Écrivez une fonction qui reçoit en paramètres un tableau d'entiers ainsi que le nombre de lignes et le
nombre de colonnes du tableau. La fonction retourne le plus petit élément du tableau.
int plus_petit_2D(int tableau[][NB_COLONNES],
int nb_lignes, int nb_colonnes)
{ int lig, col;
int pluspetit = MAXLONG; //la plus grosse valeur possible!!
6
for (lig = 0; lig < nb_lignes; lig++)
for (col = 0; col < nb_colonnes; col++) {
if (tableau[lig][col] < pluspetit)
pluspetit = tableau[lig][col];
}
return pluspetit;
}
Exemple d’un APPEL à cette fonction :
#define NB_LIGNES 10
#define NB_COLONNES 10
{ int tab_entiers[NB_LIGNES][NB_COLONNES], lemin;
. . . //ici le tableau est rempli de valeurs aléatoires
lemin = plus_petit_2D(tab_entiers, NB_LIGNES, NB_COLONNES);
printf("Plus petit : %d", lemin);
}
EX_TAB_2D.cpp : Tableau à 2-dimensions avec un "typedef" pour faciliter les paramètres
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define NB_COL 10
#define NB_LIG 6
//déclaration du type pour le tableau
typedef int t_tas[NB_LIG][NB_COL];
//prototypes des fonctions qui reçoivent un "tas"
void affiche_tab_tot(const t_tas);
void remplir_tab(t_tas);
void main()
{ t_tas tab2d ={ 23, 34, 45, -23, 123, 56, 4, -56, 40, -6,
34, 64, -5, 44, -43, 4, 35, 99, -4, -45,
5, -6, 34, 33, -53, 50, -8, 156, 30, 56,
-33, -4, 98, -34, 45, -8, 0, 36, -5, 23,
78, 44, -6, 153, -3, 42, -4, 186, 78, -43,
53, 64, -4, -43, -99, 46, 34, -86, 30, 45 };
srand(time(NULL));
system("cls");
affiche_tab_tot(tab2d);
printf("\n\n");
system("pause");
7
remplir_tab(tab2d);
affiche_tab_tot(tab2d);
printf("\n\n");
system("pause");
}
void remplir_tab(t_tas tb) //reçoit un tableau et le rempli de valeurs aléatoires [-100..100]
{ int r, c;
for (r=0; r<NB_LIG; r++)
for (c=0; c<NB_COL; c++)
tb[r][c] = rand() % 201 - 100; //valeur alea. entre -100..100
}
void affiche_tab_tot(const t_tas tb) //afficher tableau avec sommes des lignes et colonnes
{ int r, c, //r - indice-rangée, c - indice-colonne
totran, totcol; //la somme des valeurs d'une ligne et d'une colonne
for (r=0; r<NB_LIG; r++) {
totran=0;
for (c=0; c<NB_COL; c++) {
printf("%5d", tb[r][c]); //afficher la valeur
totran += tb[r][c]; //on fait un total pour chaque rangée
}
printf("%5d", totran); //afficher total de la rangée "r"
printf("\n"); //changement de ligne pour chaque "r" seulement
}
//totaux des colonnes
printf("\n");
for (c=0; c<NB_COL; c++) {
totcol=0;
for (r=0; r<NB_LIG; r++) {
totcol += tb[r][c]; //on fait un total pour chaque colonne
}
printf("%5d", totcol); //afficher total de la colonne "c"
}
}
RAPPEL : le préfixe « const » devant le paramètre « tb » indique que le contenu de « tb » ne peut
être modifié dans la fonction (même si le tableau a été passé en référence).
8
6.6 Les Fichiers Texte :
Un fichier texte (*.txt ou *.dat) peut être vu comme une suite de caractères ASCII. Un
programme peut lire des données à partir d’un fichier texte (plutôt qu’à partir du clavier), ou bien
écrire des résultats dans un fichier texte (plutôt qu’à l’écran).
En langage C, le type FILE * (de <stdio.h>) est utilisé pour déclarer un pointeur à un fichier
externe à partir d’un programme. On accède ensuite au fichier à partir de ce pointeur.
Ex. Déclaration de 2 pointeurs de fichiers :
FILE *fentree, *fsortie;
Pour ouvrir un fichier et associer son adresse au pointeur FILE *, on utilise :
pointeur_FILE = fopen("nom", "mode");
nom complet avec le chemin
d’accès si nécessaire
Les « modes » d’ouverture de fichier avec « fopen » :
"r" → ouvrir le fichier pour la lecture seulement
"w" → ouvrir le fichier pour écriture à partir du début
"a" → ouvrir le fichier pour écriture à partir de la fin (ajouter au fichier)
"r+"
ouvrir le fichier pour la lecture + écriture
"w+"
Ex. fentree = fopen("c:\\[Link]", "r");
fsortie = fopen("c:\\bidon\\[Link]", "w");
Ensuite, pour faire la lecture de données à partir du pointeur fentree on utilise :
char fgetc(FILE *ptr); → renvoie le prochain caractère à lire dans le fichier *ptr.
char *fgets(char *str, int n, FILE *ptr); → va lire une chaîne de caractères
de longueur maximale (n-1) dans la chaîne *str à partir du fichier *ptr
NOTE : la fonction renvoie également un pointeur sur le début de la chaîne lue.
int fscanf( pointeur_FILE, liste d’arguments );
comme avec le scanf()
NOTE : la fonction renvoie le nombre de lectures valides effectuées (comme scanf()).
Pour écrire des données dans le fichier associé à fsortie on utilise :
char fputc(char c, FILE *ptr); → va écrire le caractère c à la fin du fichier *ptr.
NOTE : En cas de réussite, la fonction renvoie le caractère qui a été écrit dans le fichier.
int fputs(const char *str, FILE *ptr); → va écrire la chaîne de caractères *str
à la fin du fichier pointé par *ptr. La fonction renvoie le nombre de caractères ajoutés au fichier.
9
int fprintf( pointeur_FILE, liste d’arguments );
comme avec le printf()
Exemple : Voici le contenu du fichier « [Link] » ;
3 8 12 7 9 6 <EOF> //EOF → caractère de fin de fichier
Pour faire la somme des valeurs dans ce fichier :
int val, somme=0;
FILE *fentree, *fsortie;
fentree = fopen("[Link]", "r"); //ouverture du fichier
while (fscanf(fentree, "%d", &val)==1)
somme += val;
Pour écrire cette somme dans le fichier de sortie :
fsortie = fopen("[Link]", "w"); //créer le fichier-résultat
fprintf(fsortie, "somme = %d\n", somme);
OU on peut générer la chaine de sortie avec « sprintf() » et ensuite l’écrire dans « fsortie » :
char chaine[80];
sprintf(chaine, "somme = %d", somme); //écrit dans « chaine »
fprintf(fsortie, "%s\n", chaine); //dans le fichier avec le ‘\n’
fclose(fentree); IMPORTANT, pour
fclose(fsortie); fermer les deux fichiers
NOTEZ : Quand on utilise le mode "w" ou "a" avec « fopen », si le fichier demandé n’existe
pas à l’emplacement courant, « fopen » va créer ce fichier. Avec le mode "r", le fichier doit déjà
exister. Si le « fopen » n’a pas fonctionné, il va renvoyer l’adresse NULL.
Validation correcte d’un fopen :
fentree = fopen("[Link]", "r"); //ouverture du fichier
if (fentree==NULL) {
printf("Erreur d’ouverture de fichier");
exit(1); //sortie immédiate du programme
}
Cette opération de validation peut aussi être effectuée en faisant :
assert(fentree); //il faut inclure la librairie <assert.h>
Autres fonctions de fichiers utiles :
rewind(FILE *); → renvoie le pointeur au début du fichier pour relire/réécrire
feof(FILE *); → fonction qui renvoie 1 si le pointeur est positionné à la fin du fichier,
sinon renvoie 0. Eg. while (!feof(fentree)){ … }
10
[Link] : Exemple de lecture de fichier texte avec des entiers
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define FIN -1 //valeur spéciale de fin de données
void main(void)
{ FILE *entree; //variable pointeur-fichier
int n;
printf("Entrer des chiffres ...<-1> lorsque vous aurez termine\n\n");
entree = fopen("[Link]", "w"); //ouverture du fichier, mode écriture
do {
scanf("%d",&n); //on saisit un entier au clavier..
if (n != FIN)
fprintf(entree,"%d ", n); //..et on copie dans le fichier texte
} while (n != FIN); //..jusqu'au caractère de fin de données
fclose(entree); //fermer le fichier
entree = fopen("[Link]", "r"); //ré-ouvrir le fichier en mode lecture
printf("\n\nContenu du fichier [Link]\n\n");
fscanf(entree,"%d", &n); //lire un entier à partir du fichier
while (!feof(entree)) { //tant que c'est pas la fin du fichier
printf("%d ",n); //..écrire l'entier lu à l'écran
fscanf(entree,"%d", &n); //..et lire le prochain entier
}
fclose(entree); //fermer le fichier
}
LECTFICH.c : Exemple pour lire une matrice de nombres réels à partir d'un fichier
#define _CRT_SECURE_NO_WARNINGS
#include<stdlib.h>
#include<stdio.h>
#include<assert.h> //pour la fonction de validation automatique “assert()”
#define MAXDIM 20 //ceci est une taille MAXIMALE, pas la taille actuelle!
/*----------------------------------------------------------------------*/
/* Ici l'affichage de la matrice est rectangulaire. */
void affich_mat(double mat[][MAXDIM], int taille)
{ int i, j;
for (i=0; i<taille; i++) {
for (j=0; j<taille; j++)
printf("%7.2lf", mat[i][j]);
printf("\n"); //après chaque ligne affichée, on change de ligne
}
}
11
/*-----------------------------------------------------------------------*/
/* Fonction pour lire une matrice d'un fichier texte. La fonction reçoit
un pointeur sur le fichier. Elle renvoie la taille carrée de la matrice
lue. Le format du fichier est standard : la première ligne nous donne
la taille, et les lectures suivantes sont les éléments de la matrice. */
int flire_mat(FILE * fichier, double mat[][MAXDIM])
{ int i, j, taille;
double x;
fscanf(fichier, "%d", &taille); //lecture du nombre de lignes de données
if (taille <= MAXDIM) {
for(i=0; i < taille; i++)
for(j=0; j < taille; j++){
fscanf(fichier, "%lf", &x);
mat[i][j] = x; /* NOTE! on utilise une variable temporaire pour lire
du fichier et ensuite on l'envoie dans la matrice */
}
}
fclose(fichier);
return taille;
}
/*-------------------------------------------------------------------------*/
int main()
{ double valeurs[MAXDIM][MAXDIM]; /* la matrice des valeurs */
int taille; /* taille carrée de la matrice lue */
FILE * fichier; /* pointeur sur le fichier-texte */
fichier = fopen("[Link]", "r");
assert(fichier); /* validation du fopen() */
taille = flire_mat(fichier, valeurs); /* on rempli la matrice.. */
affich_mat(valeurs, taille); /* ..et on l'affiche */
return 0;
}
Voici le contenu du fichier-texte "[Link]" :
12