Tableaux en Langage C : Exercices Corrigés
Tableaux en C : cours pratique, exemples et exercices corrigés
Maîtrisez les tableaux à une dimension, les tableaux multidimensionnels, les tableaux dynamiques, les fonctions manipulant des tableaux, les pointeurs, les allocations mémoire ainsi que les principales techniques utilisées dans les applications professionnelles grâce à des explications détaillées, des programmes complets, des cas pratiques et de nombreux exercices corrigés.
Tableaux statiques
Déclaration, initialisation, parcours, recherche, tri, copie et manipulation des tableaux classiques.
Matrices
Tableaux à deux dimensions, matrices, affichage, calculs, parcours ligne par ligne et applications numériques.
Tableaux dynamiques
malloc(), calloc(), realloc(), free(), redimensionnement, gestion de la mémoire et bonnes pratiques.
Exercices corrigés
Exercices progressifs, programmes commentés, solutions détaillées et erreurs fréquentes expliquées.
✔ Déclaration des tableaux • ✔ Initialisation • ✔ Parcours avec les boucles • ✔ Fonctions manipulant les tableaux • ✔ Tableaux de chaînes de caractères • ✔ Matrices • ✔ Pointeurs et tableaux • ✔ Allocation dynamique • ✔ Cas pratiques • ✔ Exercices corrigés
Créer et gérer un tableau dynamique en C
Un tableau dynamique est créé pendant l’exécution du programme. Sa taille peut
dépendre d’une saisie utilisateur, d’un fichier ou d’un calcul. Sa mémoire est
réservée avec malloc, modifiée avec realloc puis libérée
avec free.
Exemple simple — Créer un tableau dynamique avec malloc
La fonction malloc réserve une zone mémoire suffisamment grande
pour contenir le nombre d’éléments demandé.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int taille;
printf("Nombre d'elements : ");
scanf("%d", &taille);
if (taille <= 0)
{
printf("La taille doit etre positive.\n");
return 1;
}
int *tableau = malloc((size_t)taille * sizeof(int));
if (tableau == NULL)
{
fprintf(stderr, "Erreur d'allocation memoire.\n");
return 1;
}
for (int i = 0; i < taille; i++)
{
tableau[i] = (i + 1) * 10;
}
printf("Contenu du tableau :\n");
for (int i = 0; i < taille; i++)
{
printf("tableau[%d] = %d\n", i, tableau[i]);
}
free(tableau);
tableau = NULL;
return 0;
}Saisir les valeurs du tableau dynamique
Chaque case du tableau peut être remplie à partir d’une saisie utilisateur.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int taille;
printf("Taille du tableau : ");
scanf("%d", &taille);
if (taille <= 0)
{
printf("Taille invalide.\n");
return 1;
}
int *tableau = malloc((size_t)taille * sizeof(int));
if (tableau == NULL)
{
fprintf(stderr, "Allocation impossible.\n");
return 1;
}
for (int i = 0; i < taille; i++)
{
printf("Valeur %d : ", i + 1);
scanf("%d", &tableau[i]);
}
printf("\nValeurs saisies : ");
for (int i = 0; i < taille; i++)
{
printf("%d ", tableau[i]);
}
printf("\n");
free(tableau);
tableau = NULL;
return 0;
}Créer le tableau dans une fonction
Une fonction peut créer un tableau dynamique puis retourner son adresse.
#include <stdio.h>
#include <stdlib.h>
int *creerTableau(int taille)
{
if (taille <= 0)
{
return NULL;
}
int *tableau = malloc((size_t)taille * sizeof(int));
if (tableau == NULL)
{
return NULL;
}
for (int i = 0; i < taille; i++)
{
tableau[i] = i + 1;
}
return tableau;
}
int main(void)
{
int taille = 5;
int *valeurs = creerTableau(taille);
if (valeurs == NULL)
{
fprintf(stderr, "Impossible de creer le tableau.\n");
return 1;
}
for (int i = 0; i < taille; i++)
{
printf("%d ", valeurs[i]);
}
free(valeurs);
valeurs = NULL;
return 0;
}free.Initialiser un tableau dynamique avec calloc
La fonction calloc réserve la mémoire et initialise automatiquement
tous les octets à zéro.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int taille = 6;
int *tableau = calloc((size_t)taille, sizeof(int));
if (tableau == NULL)
{
fprintf(stderr, "Erreur d'allocation.\n");
return 1;
}
for (int i = 0; i < taille; i++)
{
printf("tableau[%d] = %d\n", i, tableau[i]);
}
free(tableau);
tableau = NULL;
return 0;
}calloc, les éléments numériques commencent généralement à zéro.Agrandir un tableau dynamique avec realloc
La fonction realloc permet de modifier la taille d’une zone mémoire
déjà allouée.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int ancienneTaille = 3;
int nouvelleTaille = 6;
int *tableau = malloc(
(size_t)ancienneTaille * sizeof(int)
);
if (tableau == NULL)
{
fprintf(stderr, "Erreur d'allocation.\n");
return 1;
}
for (int i = 0; i < ancienneTaille; i++)
{
tableau[i] = (i + 1) * 10;
}
int *temporaire = realloc(
tableau,
(size_t)nouvelleTaille * sizeof(int)
);
if (temporaire == NULL)
{
free(tableau);
fprintf(stderr, "Erreur pendant realloc.\n");
return 1;
}
tableau = temporaire;
for (int i = ancienneTaille; i < nouvelleTaille; i++)
{
tableau[i] = (i + 1) * 10;
}
for (int i = 0; i < nouvelleTaille; i++)
{
printf("%d ", tableau[i]);
}
free(tableau);
tableau = NULL;
return 0;
}realloc.
Une affectation directe pourrait faire perdre l’adresse initiale en cas d’échec.Structure complète — Tableau dynamique redimensionnable
Cette version regroupe le pointeur, la taille utilisée et la capacité totale dans une structure.
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
int *donnees;
size_t taille;
size_t capacite;
} TableauDynamique;
int initialiserTableau(
TableauDynamique *tableau,
size_t capaciteInitiale
)
{
if (tableau == NULL || capaciteInitiale == 0)
{
return 0;
}
tableau->donnees = malloc(
capaciteInitiale * sizeof(int)
);
if (tableau->donnees == NULL)
{
tableau->taille = 0;
tableau->capacite = 0;
return 0;
}
tableau->taille = 0;
tableau->capacite = capaciteInitiale;
return 1;
}
int ajouterValeur(
TableauDynamique *tableau,
int valeur
)
{
if (tableau == NULL)
{
return 0;
}
if (tableau->taille == tableau->capacite)
{
size_t nouvelleCapacite =
tableau->capacite * 2;
int *temporaire = realloc(
tableau->donnees,
nouvelleCapacite * sizeof(int)
);
if (temporaire == NULL)
{
return 0;
}
tableau->donnees = temporaire;
tableau->capacite = nouvelleCapacite;
}
tableau->donnees[tableau->taille] = valeur;
tableau->taille++;
return 1;
}
void afficherTableau(
const TableauDynamique *tableau
)
{
if (tableau == NULL)
{
return;
}
printf("Tableau : ");
for (size_t i = 0; i < tableau->taille; i++)
{
printf("%d ", tableau->donnees[i]);
}
printf("\n");
}
void libererTableau(
TableauDynamique *tableau
)
{
if (tableau == NULL)
{
return;
}
free(tableau->donnees);
tableau->donnees = NULL;
tableau->taille = 0;
tableau->capacite = 0;
}
int main(void)
{
TableauDynamique tableau;
if (!initialiserTableau(&tableau, 2))
{
fprintf(stderr, "Initialisation impossible.\n");
return 1;
}
ajouterValeur(&tableau, 10);
ajouterValeur(&tableau, 20);
ajouterValeur(&tableau, 30);
ajouterValeur(&tableau, 40);
ajouterValeur(&tableau, 50);
afficherTableau(&tableau);
printf("Taille : %zu\n", tableau.taille);
printf("Capacite : %zu\n", tableau.capacite);
libererTableau(&tableau);
return 0;
}Supprimer un élément du tableau dynamique
Pour supprimer un élément, les valeurs situées après sa position sont décalées vers la gauche.
int supprimerValeur(
TableauDynamique *tableau,
size_t position
)
{
if (tableau == NULL || position >= tableau->taille)
{
return 0;
}
for (size_t i = position; i + 1 < tableau->taille; i++)
{
tableau->donnees[i] =
tableau->donnees[i + 1];
}
tableau->taille--;
return 1;
}Exemple d’utilisation
supprimerValeur(&tableau, 1);
afficherTableau(&tableau);Cas particulier — Tableau dynamique à deux dimensions
Une matrice dynamique peut être créée sous la forme d’un tableau de pointeurs.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int lignes = 3;
int colonnes = 4;
int **matrice = malloc(
(size_t)lignes * sizeof(int *)
);
if (matrice == NULL)
{
return 1;
}
for (int i = 0; i < lignes; i++)
{
matrice[i] = malloc(
(size_t)colonnes * sizeof(int)
);
if (matrice[i] == NULL)
{
for (int j = 0; j < i; j++)
{
free(matrice[j]);
}
free(matrice);
return 1;
}
}
for (int i = 0; i < lignes; i++)
{
for (int j = 0; j < colonnes; j++)
{
matrice[i][j] = i + j;
}
}
for (int i = 0; i < lignes; i++)
{
for (int j = 0; j < colonnes; j++)
{
printf("%d ", matrice[i][j]);
}
printf("\n");
}
for (int i = 0; i < lignes; i++)
{
free(matrice[i]);
}
free(matrice);
matrice = NULL;
return 0;
}Erreurs fréquentes avec les tableaux dynamiques
| Erreur | Conséquence | Correction |
|---|---|---|
Ne pas tester malloc | Utilisation possible d’un pointeur nul | Vérifier que le résultat est différent de NULL |
Oublier free | Fuite de mémoire | Libérer toute mémoire qui n’est plus utilisée |
Utiliser le pointeur après free | Comportement indéfini | Mettre le pointeur à NULL |
| Dépasser la taille allouée | Écriture hors mémoire | Contrôler les indices et la capacité |
Affecter directement realloc | Perte du pointeur initial en cas d’échec | Utiliser un pointeur temporaire |
| Libérer deux fois le même pointeur | Erreur mémoire grave | Mettre le pointeur à NULL après libération |
malloc, calloc et realloc — Tableau comparatif
| Fonction | Utilisation | Initialisation |
|---|---|---|
malloc | Créer une nouvelle zone mémoire | Contenu non initialisé |
calloc | Créer un tableau de plusieurs éléments | Mémoire initialisée à zéro |
realloc | Agrandir ou réduire une zone existante | Les nouvelles cases ne sont pas initialisées |
free | Libérer la mémoire allouée | Le pointeur ne doit plus être utilisé |
Fonctions qui Retournent des Tableaux en C
Les tableaux en langage C : méthodes, exemples et exercices corrigés
Voici une série d’exercices corrigés sur les tableaux en langage C, allant des bases aux concepts plus avancés. Ces exercices vous aideront à mieux comprendre la manipulation des tableaux et les opérations associées.
Exercice 1 : Remplir un tableau et afficher ses éléments
Énoncé :
Écrivez un programme en C qui remplit un tableau de 5 entiers donnés par l’utilisateur et affiche ensuite les éléments du tableau.
Correction :
#include <stdio.h>
int main() {
int tableau[5];
// Saisie des éléments du tableau
for(int i = 0; i < 5; i++) {
printf("Entrez l'élément %d : ", i + 1);
scanf("%d", &tableau[i]);
}
// Affichage des éléments du tableau
printf("Les éléments du tableau sont :\n");
for(int i = 0; i < 5; i++) {
printf("%d ", tableau[i]);
}
printf("\n");
return 0;
}Explication :
- Le tableau
tableau[5]est utilisé pour stocker 5 entiers. - Une boucle
forremplit le tableau avec les entrées de l’utilisateur. - Une deuxième boucle
foraffiche les éléments du tableau.
Exercice 2 : Trouver la valeur maximale d’un tableau
Énoncé :
Écrivez un programme en C qui demande à l’utilisateur de remplir un tableau de 10 entiers, puis trouve et affiche la valeur maximale dans ce tableau.
Correction :
#include <stdio.h>
int main() {
int tableau[10];
int max;
// Saisie des éléments du tableau
for (int i = 0; i < 10; i++) {
printf("Entrez l'élément %d : ", i + 1);
scanf("%d", &tableau[i]);
}
// Initialisation de la variable max avec le premier élément du tableau
max = tableau[0];
// Recherche du maximum
for (int i = 1; i < 10; i++) {
if (tableau[i] > max) {
max = tableau[i];
}
}
// Affichage du maximum
printf("La valeur maximale est : %d\n", max);
return 0;
}Explication :
- Le programme initialise la variable
maxavec le premier élément du tableau. - Ensuite, une boucle parcourt les autres éléments du tableau pour trouver le plus grand élément.
Exercice 3 : Calcul de la moyenne d’un tableau
Énoncé :
Écrivez un programme en C qui lit 5 nombres flottants, les stocke dans un tableau, et affiche ensuite la moyenne de ces nombres.
Correction :
#include <stdio.h>
int main() {
float tableau[5], somme = 0.0, moyenne;
// Saisie des éléments du tableau
for(int i = 0; i < 5; i++) {
printf("Entrez l'élément %d : ", i + 1);
scanf("%f", &tableau[i]);
somme += tableau[i]; // Ajouter chaque élément à la somme
}
// Calcul de la moyenne
moyenne = somme / 5;
// Affichage de la moyenne
printf("La moyenne des éléments est : %.2f\n", moyenne);
return 0;
}Explication :
- Le tableau
tableau[5]contient des nombres flottants. - À chaque itération, les éléments sont ajoutés à la somme, et à la fin, la moyenne est calculée en divisant la somme par 5.
Exercice 4 : Inverser les éléments d’un tableau
Énoncé :
Écrivez un programme en C qui lit 6 entiers, les stocke dans un tableau, puis affiche les éléments dans l’ordre inverse.
Correction :
#include <stdio.h>
int main() {
int tableau[6];
// Saisie des éléments du tableau
for(int i = 0; i < 6; i++) {
printf("Entrez l'élément %d : ", i + 1);
scanf("%d", &tableau[i]);
}
// Affichage des éléments dans l'ordre inverse
printf("Les éléments du tableau dans l'ordre inverse sont :\n");
for(int i = 5; i >= 0; i--) {
printf("%d ", tableau[i]);
}
printf("\n");
return 0;
}Explication :
- Le programme lit 6 entiers dans un tableau.
- Ensuite, une boucle
forinverse les éléments en commençant par le dernier et en affichant chaque élément.
Exercice 5 : Tri d’un tableau (Tri par sélection)
Énoncé :
Écrivez un programme en C qui lit 5 entiers, les stocke dans un tableau, puis les trie dans l’ordre croissant en utilisant l’algorithme du tri par sélection.
Correction :
#include <stdio.h>
int main() {
int tableau[5], i, j, min, temp;
// Saisie des éléments du tableau
for(i = 0; i < 5; i++) {
printf("Entrez l'élément %d : ", i + 1);
scanf("%d", &tableau[i]);
}
// Tri par sélection
for(i = 0; i < 4; i++) {
min = i;
for(j = i + 1; j < 5; j++) {
if(tableau[j] < tableau[min]) {
min = j;
}
}
// Échange des éléments
temp = tableau[min];
tableau[min] = tableau[i];
tableau[i] = temp;
}
// Affichage du tableau trié
printf("Le tableau trié est :\n");
for(i = 0; i < 5; i++) {
printf("%d ", tableau[i]);
}
printf("\n");
return 0;
}Explication :
- Le programme utilise l’algorithme du tri par sélection pour trier un tableau de 5 entiers.
- À chaque itération, il trouve l’élément minimum dans la partie non triée du tableau et le place à la position correcte en l’échangeant avec l’élément actuel.
Exercice 6 : Fusionner deux tableaux
Énoncé :
Écrivez un programme en C qui lit deux tableaux de 5 entiers chacun, puis les fusionne dans un troisième tableau.
Correction :
#include <stdio.h>
int main() {
int tableau1[5], tableau2[5], tableau_fusion[10];
// Saisie des éléments du premier tableau
printf("Entrez les éléments du premier tableau :\n");
for(int i = 0; i < 5; i++) {
scanf("%d", &tableau1[i]);
}
// Saisie des éléments du deuxième tableau
printf("Entrez les éléments du deuxième tableau :\n");
for(int i = 0; i < 5; i++) {
scanf("%d", &tableau2[i]);
}
// Fusion des deux tableaux
for(int i = 0; i < 5; i++) {
tableau_fusion[i] = tableau1[i];
tableau_fusion[i + 5] = tableau2[i];
}
// Affichage du tableau fusionné
printf("Le tableau fusionné est :\n");
for(int i = 0; i < 10; i++) {
printf("%d ", tableau_fusion[i]);
}
printf("\n");
return 0;
}Explication :
- Le programme fusionne les éléments des deux tableaux de 5 entiers dans un troisième tableau de 10 entiers.
- Le premier tableau est copié dans la première moitié du tableau fusionné, et le deuxième tableau est copié dans la deuxième moitié.
Ces exercices tableaux en langage C vous permettent de pratiquer les bases et des concepts légèrement plus avancés liés aux tableaux en C. Vous pouvez essayer d’autres variantes, comme implémenter des algorithmes de tri plus complexes ou travailler sur des tableaux dynamiques.
