TP 2 : Tableaux et pointeurs
Classe MP2I
20 septembre 2023
Tableaux statiques
On peut déclarer un tableau de la manière suivante :
int t[10]; // tableau de 10 entiers, non initialisé
double u[3] = {1.2, 3.4, 2.5} // tableau de 3 doubles, initialisé
int v[] = {1, 2, 7, 8} //tableau de 4 entiers intialisé: la taille est
déduite de l'initialisation
Les éléments d’un tableau sont indicés à partir de 0, et on accède à un élément par t[indice].
Les éléments du tableau u défini ci-dessus sont donc u[0], u[1] et u[2].
■ Si le tableau n’est pas initialisé explicitement (cas du tableau t ci-dessus) :
— si c’est une variable globale, les éléments sont implicitement initialisés à zéro ;
— si c’est une variable locale, dans la norme c, les éléments ne sont pas initialisés, et
ont au départ une valeur quelconque (une ancienne valeur stockée dans le même
espace mémoire de la variable). Exceptionnellement, certains compilateurs initialisent à
0 les bits de la zone mémoire d’une variable non initialisée.
■ La taille d’un tel tableau doit absolument être connue statiquement (c’est-à-dire à la
compilation).
La taille doit être une constante littérale :
int t[10]; // OK
int n = 10;
int u[n]; // NON dans le C standard, OUI à partir de la norme C99
const int p = 5;
int v[p]; // NON dans le C standard OUI à partir de la norme C99
Exercice 1 :
On part du squelette suivant avec un tableau défini comme une variable globale :
1
#include <stdio.h>
#include <stdlib.h>
const int taille = 10;
int tab[10];
Noter que si l’on veut modifier le code pour que le tableau soit de taille 10, il faut modifier
à la fois la constante taille que l’on utilisera pour les boucles dans le programme et le 10 qui
apparaît dans la définition de tab (ce n’est évidemment pas satisfaisant, et nous verrons
ultérieurement comment améliorer cela)..
1. La fonction int rand(void) , déclarée dans stdlib.h , renvoie un entier positif
aléatoire.
Écrire une fonction void remplir(void) qui remplit le tableau global tab avec des
entiers tirés aléatoirement.
Le code suivant permet de générer un nombre aléatoire dans un intervalle [a, b]
srand(time(NULL));// Initialisation du générateur de nombres aléatoires en
fonction du temps
int alea = a + rand() % (b - a + 1);
2. Écrire une fonction void affiche(void) qui affiche le contenu du tableau tab (en
séparant les entiers par un espace et en revenant à la ligne à la fin).
3. Écrire une fonction int min(void) qui renvoie le minimum du tableau tab .
4. Écrire une fonction int indice_min(void) qui renvoie l’indice de la première
occurrence du minimum dans tab.
Manipulation des pointeurs
Exercice 2 :
On considère le code suivant :
#include <stdio.h>
int n = 3;
int p;
int f(int n){
int* p = &n;
int x = n + *p;
return x + 1;
}
int g(int x, int y){
int z = f(x);
return z + f(y);
}
int main(void){
2
p = 4;
int result = g(n, p);
printf("result = %d\n", result);
return 0;
}
Recopiez le code dans votre éditeur gedit, compiler et visualiser l’exécution pas à pas du
programme. Essayer de bien comprendre ce qui se passe.
Exercice 3 :
Dans chacun des cas suivants :
● déterminer si le programme est « faux » (lecture d’une variable non initialisée,
déréférencement d’un pointeur invalide, erreur de type. . .) ;
● écrire sur papier (sans exécuter le programme) ce qu’on obtiendrait sur votre machine
(évolution du schéma mémoire et affichage produit) ;
● copier le code sur gedit et vérifier.
1.
#include <stdio.h>
#include <stdbool.h>
void print_bool(bool b){
if (b){
printf("true\n");
} else {
printf("false\n");
}
}
int main(void){
double pi = 3.14;
double e;
double* p = NULL;
p = &e;
*p = pi;
print_bool(e == pi);
pi = 4.5;
print_bool(e == pi);
}
2.
#include <stdio.h>
3
#include <stdbool.h>
int x = 7;
int y = 12;
int* p;
int f(int x){
printf("x = %d\n", x);
printf("y = %d\n", y);
printf("*p = %d\n", *p);
int y = 1;
printf("y = %d\n", y);
x = x + y;
return x;
}
int main(void){
int z;
p = &x;
z = f(x + 1);
printf("z = %d\n", z);
return 0;
}
Exercice 4 :
On souhaite écrire une fonction echange qui échange la valeur de deux variables entières.
void echange(int a, int b)
{
int tmp = a;
a = b;
b = tmp;
}
1. Le code ci-dessus ne fonctionne pas. Pourquoi ?
2. proposer une fonction echange qui permette d’échanger deux variables entières.
3. Écrire une fonction void affiche_entiers(int *tab, int n) qui affiche les valeurs
d’un tableau d’entiers de taille n.
4. Écrire une fonction void affiche_floats(float *tab, int n) qui affiche les
valeurs d’un tableau de flottants de taille n.
Exercice 5 :
On rappelle qu’on peut allouer nous-même de la mémoire à l’aide de la fonction malloc,
et de la libérer avec la fonction free.
4
1. Écrire une fonction int *copie(int *tab, int n) qui prend en arguments un
tableau d’entiers tab et sa taille n, et qui renvoie une copie de ce tableau.
2. Tester que votre code fournit bien une copie : dans la fonction main, créer un tableau
tab1 et sa copie tab2, puis modifier tab2 et afficher les valeurs des deux tableaux à
l’aide de la fonction affiche_entiers.
Exercice 6 : Triangle de Pascal
Dans cet exercice, on veut créer des tableaux t de taille n + 1 tels que t[i] = (c’est la n-
ème ligne du triangle de Pascal).
Exemple :
Int t0[] = {1};
Int t1[] = {1, 1};
Int t2[] = {1, 2, 1};
Int t3[] = {1, 3, 3, 1};
Étant donné un tel tableau t (pour un certain n), on peut construire le tableau représentant la
ligne n + 1 comme suit :
● on crée un tableau de taille n + 2 ;
● on met 1 dans la première et la dernière case ;
● pour tout autre case (d’indice i), on met la valeur de t[i-1] + t[i].
1. Écrire une fonction int *prochaine_ligne(int *t, int n) implémentant cet
algorithme.
2. Écrire une fonction int **triangle_de_pascal(int n) qui renvoie un tableau
contenant les n premières lignes du triangle de Pascal.
3. Afficher les 10 premières lignes du triangle de Pascal.
Exercice 7: tableaux de structures
Développer une application qui permet la gestion des machines en panne.
Une machine est caractérisée par :
● Une référence (entier unique)
● Un nombre de pannes.
● Un tableau de pannes
Une panne est caractérisée par :
● Une référence (chaîne de caractères)
● Un état (1: réparée ou 0: non)
5
On vous demande d’implémenter les fonctions suivantes :
− machine * chercher (machine Tm [],int n, int ref) ; qui permet de chercher une
machine donnée par sa référence et de retourner son adresse si elle existe sinon
NULL.
− void saisir (………….) ; qui permet de saisir une machine avec une référence
unique. Initialement le nombre de pannes est nul.
− void ajouter (machine * t, int * n, machine m) ; qui permet d’ajouter une
machine dans un tableau de machine.
− int chercherPanne (machine m,char * refP ) ; qui permet de chercher une panne
donnée par sa référence dans une machine m.
− void saisirPanne(……..) ; qui permet de saisir les informations d’une panne.
− void ajouterPanne(int ref, machine Tm[], int n, panne p) ; qui permet d’ajouter
une panne à une machine donnée par sa référence.
− void modifierEtatPanne( machine * p, char refpanne[]); qui permet de modifier
l'état d'une panne donné par sa référence ( de non réparée ==> réparée) d'une machine
donnée par son adresse.
− void afficher (……………….) ; qui permet d’afficher toutes les machines.
− void calculerPannes (machine Tm[], int n, int *n_rep, int *n_nrep, int ref) ; qui
calcule le nombre total des pannes réparées dans n_rep et celui des pannes non
réparées dans n_nrep pour une machine donnée par sa référence.
− void trier (…….) qui permet de trier les machines par ordre croissant du
nombre total de pannes.
− void supprimer (……..) ; qui permet de supprimer les machines ayant toutes les
pannes réparées .
6
7
