Par O. Bailleux, Maître de conférences HDR à l'université de Bourgogne.
Tableaux et pointeurs
Les activités #.dec (dec pour Découverte) consistent à étudier des présentations explicatives et à traiter tous les exercices de découverte proposés. Si vous ne répondez pas correctement à un exercice de découverte, revenez en arrière pour relire les explications et identifier la cause de votre erreur.
Les activités #.ent (ent pour Entrainement) consistent à traiter des exercices d’entraînement. Vous devez d’abord tenter de traiter ces exercices sans dévoiler d’indice ni regarder la solution. Vous pouvez remonter dans le document pour relire certaines explications ou consulter les solutions des exercices de découverte ou d’entraînement précédemment traités.
Activité de découverte C.dec
C.dec1 : Pointeur et paramètres de type pointeur
Prérequis
| Partie A et types entiers décrits dans la partie B. |
|---|
Objectif
| Réaliser une fonction qui modifie des variables situées n’importe où dans le programme. |
|---|
Prenons un exemple pour introduire notre objectif. Examinons la fonction suivante.
void test()
{
int a = rand()%10; // Bloc A
int b = rand()%10;
if(a>b) // Bloc B
{
int tmp = a; a = b; b = tmp;
}
printf("%d %d\n",a,b);
}
Quel est l’effet de l’exécution de cette fonction ? Tentez de répondre sans utiliser d’ordinateur.
L’affichage d’une suite croissante de deux valeurs aléatoires comprises entre 0 et 9.
Le principe consiste produire deux valeurs aléatoire placées dans les variables a et b, puis, si la première valeur est plus grande que la deuxième, à échanger les contenus des deux variables. Cette opération de tri des deux valeurs est réalisée par le bloc B.
On souhaite déléguer cette opération de remise en ordre des valeurs de a et b à une fonction nommée reorder. Si on procède de la manière suivante,…
void reorder(int a, int b)
{
if(a>b)
{
int tmp = a; a = b; b = tmp;
}
}
void test()
{
int a = rand()%10;
int b = rand()%10;
reorder(a,b);
printf("%d %d\n",a,b);
}
…ça ne fonctionne pas. Si on fait des affichages de a et b avant et après appel à reorder, on constate que l’appel de cette fonction n’a strictement aucun effet sur les variables a et b.
Pour comprendre exactement pourquoi, il faut faire un dessin de ce qui se passe en mémoire à la fin de l’exécution de reorder appelée par test.

Tout ce qui est représenté par cette illustration se situe dans une zone mémoire appelée pile d’exécution, ou simplement pile, dans laquelle sont stockés les contenus de toutes les variables locales, aussi appelées variables automatiques, c’est à dire les variables déclarées à l’intérieur du corps d’une fonction.
On y voit les deux variables de la fonction test, en supposant qu’elles aient reçu respectivement les valeurs 7 et 4. Ces variables n’existent que pendant l’exécution de la fonction dans laquelle elles sont déclarées.
Lors de l’appel de reorder, les valeurs des variables a et b de test sont copiées dans les paramètres de la fonction reorder, qui sont des variables locales de cette fonction.
Retenez bien ceci : les paramètres d’une fonction sont des variables locales à part entière, qui sont initialisées avec les valeurs passées en arguments (on dit parfois aussi passés en paramètres) lors de l’appel de la fonction.
L’exécution de la fonction reorder a pour effet d’échanger les contenus de ses deux variables locales a et b, mais ceci n’a aucun effet sur les variables de la fonction test. En résumé, une fonction appelée par des variables en argument va travailler avec des copies des valeurs de ces variables. C’est d’ailleurs souhaitable dans beaucoup de situation car cela évite les effets de bord, c’est à dire la modification par une fonction d’une variable extérieure à cette fonction.
Moyen
| Utiliser des pointeurs |
|---|
Il arrive qu’on souhaite qu’une fonction puisse modifier des variables qui lui sont extérieure. Dans ce cas on peut utiliser des pointeurs. Un pointeur est une adresse mémoire à laquelle se trouve une donnée, telle que par exemple le contenu d’une variable. Il est possible d’utiliser des variables de type pointeur, c’est à dire des variables qui contiennent des adresses mémoire.
Reprenons l’exemple précédent avec une implémentation qui fonctionne grâces à des pointeurs.
void reorder(int* p, int* q) // Ligne A
{
if(*p > *q) // Ligne B
{
int tmp = *p; *p = *q; *q = tmp; // Ligne C
}
}
void test()
{
int a = rand()%10;
int b = rand()%10;
reorder(&a, &b); // Ligne D
printf("%d %d\n",a,b);
}
Il y a trois nouvelles notations qui apparaissent ici, et il faut prendre le temps de les expliquer. Dans toutes la suite de l’enseignement, ces notations seront très souvent utilisées. Si vous les confondez, vous ferez des erreurs.
En ligne A, les paramètre de la fonction reorder sont de type int*, c’est à dire pointeur sur int. Ces paramètres doivent recevoir des adresses mémoires auxquelles se trouvent des données de type int.
En ligne B, la notation *p désigne la donnée pointée par p, c’est à dire la donnée de type int située en mémoire à l’adresse contenue dans la variable p. La condition de l’instruction if ne compare pas les adresses, mais les valeurs pointées par les adresses qui ont été transmises en arguments et qui sont contenues dans les paramètres p et q.
En ligne C, on échange les valeurs pointées par les paramètres p et q.
En ligne D, la notation &a désigne l’adresse mémoire de la variable locale a. Ce sont donc les pointeurs sur a et b qui sont transmis en argument à la fonction reorder.
Un nouveau dessin montre ce qui se passe en mémoire à la fin de l’exécution de reorder appelée par test.

On aurait tout aussi bien pu appeler les paramètres de reorder a et b, plutot que p et q. Le changement de nom a pour seul but une meilleure lisibilité. Maintenant, le programme fonctionne parfaitement.
Revenons sur les trois nouvelles notations.
int*représente le type pointeur surint. tous les types peuvent être pointés. On peut utiliser des pointeurs surdouble,char, etc., notésdouble*,char*, etc. On peut aussi utiliser des pointeurs sur des pointeurs. Par exemple le typeint**représente l’adresse mémoire d’une variable de typeint*, donc l’adresse d’une variable contenant l’adresse d’une variable contenant un entier.- Si
xest une variable alors la notation&xreprésente l’adresse dex, de type pointeur sur le type dex. - Si
xest un pointeur ou une variable de type pointeur,*xreprésente la donnée pointée parx.
Notez au passage que le symbole * a deux usages différents, i.e. construire un type pointeur ou désigner la donnée pointée par un pointeur, en plus de son utilisation arithmétique comme symbole de multiplication. C’est le contexte qui permet au compilateur et à l’informaticienne ou l’informaticien de déterminer la signification de ce symbole.
Exercice de découverte C.dec.x1
Quelle est la valeur de x après l’exécution de ces lignes de code ?
int x = 10;
int* p = &x;
*p = *p + 1;
11
Exercice de découverte C.dec.x2
Quelle est la valeur de x après l’exécution de ces lignes de code ?
int x = 10;
int* p = &x;
p = p + 1;
10, car la valeur pointée par p n’a jamais été modifiée. Par contre le contenu de p a été modifié, sans effet sur x. Nous verrons plus bas l’effet d’ajouter une valeur entière à un pointeur.
Exercice de découverte C.dec.x3
Donnez les lignes de code permettant de réaliser la situation suivante en mémoire.

int z = 7;
int* q = &z;
int** p = &q;
Réalisez une fonction f qui ne retourne rien, accepte un paramètre p de type int* et a pour effet de mettre à 0 la variable pointée par p.
void f(int* p)
{
*p = 0;
}
Bonus
| Pointeurs sur rien et n’importe quoi, affichage d’un pointeur |
|---|
Pointeur sur rien
La valeur NULL peut être placée dans toute variable de type pointeur. Elle ne correspond pas à une adresse valide mais peut servir, par exemple, à indiquer qu’une variable de type pointeur n’a pas encore été assignée avec une adresse.
Pointeur sur n’importe quoi
Les pointeurs que nous avons vu sont typés. Il pointent sur une donnée d’un type particulier, comme par exemple int, et le compilateur utilise cette information pour détecter certaines erreurs. Mais il existe des pointeurs de type void* qui peuvent pointer sur n’importe quel type de données. Vous ne devez pas les utiliser avant d’avoir abordé la gestion dynamique de la mémoire.
Afficher un pointeur
Le format d’affichage %p permet à la fonction printf d’afficher un pointeur sous le forme d’une valeur hexadécimale. L’adresse des variables change à chaque exécution d’un programme, ce qui limite l’intérêt d’un tel affichage à des utilisations expérimentales ou pédagogiques.
C.dec2 : Tableaux statiques et automatiques
Prérequis
| Partie A et bonne compréhension de ce qu’est un pointeur. |
|---|
Objectif
| Stocker et représenter en mémoire une collection de données de même type. |
|---|
Moyen
| Utiliser un tableau |
|---|
Les tableaux sont supportés par presque tous les langages de programmation. Ils permettent d’organiser des données de même type et d’accéder à chacune de ces données à l’aide d’un indice qui est un nombre entier.
Voici un premier exemple de déclaration d’un tableau en langage C. Pour changer un peu des entiers, nous allons créer un tableau de valeurs de type double, c’est à dire de nombres représentés en virgule flottante.
double tab[5];
On donne d’abord le type de contenu de chaque cellule du tableau, puis le nom du tableau, puis, entre crochets, la taille du tableau, c’est à dire son nombre de cellules.
Si la déclaration est située dans le corps d’une fonction, alors le tableau est local à cette fonction et sa durée de vie sera la durée de l’exécution de la fonction. Ces tableaux locaux de ce genre, aussi appelés tableaux automatiques, ne peuvent pas être très grands car il sont stockés dans la pile d’exécution qui est un espace mémoire limité. Leur taille ne devrait pas excéder quelques milliers d’octets.
Si la déclaration n’est pas dans le corps d’une fonction, le tableau est global. Sa durée de vie est la durée d’exécution du programme et il est accessible depuis n’importe quelle fonction du fichier source où il est déclaré, et même au delà dans le cas d’un programme constitué de plusieurs fichiers sources, sous certaines conditions.
Un tableau local (automatique) ou global a une taille fixe, déterminée lors de sa création et qui ne peut changer pendant toute sa durée d’existence.
Chaque cellule d’un tableau s’utilise comme une variable. Dans notre exemple, les cellules sont désignées par les notations tab[0] à tab[4]. La première cellule a toujours l’indice 0.
On peut initialiser un tableau lors de sa déclaration. Voici quelques exemples.
double tab1[10] = {1.1, 2.5, 3.0};
// Initialise le tableau avec les valeurs
// 1.1, 2.5, 3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
int tab2[] = {2, 3, 5, 7};
// Crée un tableau de taille 4 initialisé
// avec 2, 3, 5, 7
double tab3[10] = {0.0};
// Toutes les cellules sont initialisées avec 0.0
Cette syntaxe n’est utilisable que lors de la déclaration du tableau. Ensuite, le seule manière de mettre des valeurs dans le tableau est de le faire cellule par cellule.
Le langage C ne stocke pas en mémoire la longueur d’un tableau, mais uniquement son contenu. Il ne vérifie pas les débordements en cours d’exécution. Voici un exemple.
void danger()
{
double tab[5] = {0,0};
tab[7] = 1.0; // ERREUR 1
tab[-1] = 2.0; // ERREUR 2
for(int i=0; i<=5; i++) // ERREUR 3
{
printf("%d ", tab[i]);
}
printf("\n");
}
Voyez vous les 3 erreurs dans cette fonction ?
les cellules tab[-1] et tab[7] n’existent pas. La dernière itération de la boucle affiche tab[5], qui n’existe pas non plus puisque le tableau a 5 cellules d’indices 0 à 4.
Pourtant, lorsque j’ai compilé et exécuté ce programme sur ma machine, il n’y a eu aucune erreur et l’affichage suivant a été produit.
0.000000 0.000000 0.000000 0.000000 0.000000 0.000000
Le programme a écrit la valeur 0.0 en mémoire à des adresses situées en dehors des limites du tableau et a également affiché une valeur située en dehors de ces limites, qui c’est trouvée par hasard égale à 0.0. Mais le comportement d’un tel programme est imprévisible. Il peut avoir pour effet d’écraser les contenus d’autres variables et de provoquer des erreurs graves. C’est au programmeur de faire en sorte de ne jamais lire ni écrire dans une cellule située en dehors d’un tableau.
Exercice de découverte C.dec.x4
Donnez les lignes de code permettant de créer un tableau d’entiers non signés de taille 10, et de remplir ce tableau avec des nombres aléatoires compris entre 1 et 10.
unsigned tab[10];
for(int i=0; i < 10; i++)
{
tab[i] = 1 + rand()%10;
}
Exercice de découverte C.dec.x5
En exécutant les lignes de codes suivantes, situées dans la méthode main…
int tab[10];
for(int i=0; i < 10; i++)
{
printf("%d ", tab[i]);
}
printf("\n");
…j’ai obtenu l’affichage suivant :
1422503880 32609 608723920 22008 0 0 608723136 22008 1130632544 32764
Tentez d’expliquer ce résultat.
Le tableau n’a pas été initialisé. Les valeurs affichées correspondent au contenu de la mémoire occupée par le tableau. Elles sont imprévisibles.
C.dec3 : Passage de tableaux en paramètres
Prérequis
| Maîtriser les pointeurs et les tableaux. |
|---|
Objectif
| Réaliser une fonction capable de lire et modifier un ou plusieurs tableaux passés en paramètres. |
|---|
Par exemple, il est pratique de disposer d’une fonction permettant d’afficher tout ou partie des valeurs contenues dans un tableau d’entiers, ou encore d’une fonction réinitialisant à 0 tout ou partie des cellules d’un tableau d’entiers. Ces fonctions doivent pouvoir être appelées avec n’importe quel tableau d’entiers, ce qui suppose d’indiquer, lors de l’appel de la fonction, le tableau à afficher ou à modifier.
Moyen
| Correspondance entre tableau et pointeur, passage d’un tableau en paramètre. |
|---|
En langage C, il y a une relation très étroite entre tableaux et pointeurs. Cette relation est souvent appelée « équivalence entre tableaux et pointeurs », mais le terme est un peu trompeur et je préfère parler de correspondance entre tableaux est pointeurs. Cette notion se résume ainsi :
- Tout nom de tableau est considéré par le compilateur C comme étant un pointeur sur la première cellule du tableau concerné.
- Tout pointeur peut être utilisé comme un nom de tableau. Mais en pratique une telle utilisation ne doit être faite que si le pointeur pointe effectivement une cellule de tableau. Dans le cas contraire, les conséquences sont imprévisibles et dangereuses : corruption de mémoire, écrasement de variables, plantage, etc.
Illustrons ce principe avec un exemple.
double tab[5] = {0.0};
double* p = tab; // Ligne A
p[2] = 3.35; // Ligne B
for(int i=0; i < 5; i++)
{
printf("%.02f ", tab[i]); // Ligne C
}
printf("\n");
L’exécution de ces lignes de code (qui doivent évidemment se trouver dans une fonction, par exemple dans main), produit l’affichage suivant :
0.00 0.00 3.35 0.00 0.00
En ligne A la variable p, de type pointeur sur double, est initialisée avec l’adresse du tableau tab.
En ligne B la variable p est utilisée pour accéder à la troisième cellule du tableau tab.
Tout ceci est rendu possible par la correspondance entre tableaux et pointeurs.
En ligne C, on affiche une cellule du tableau tab. À la place de tab[i], on aurait pu écrire p[i].
À présent, corsons un peu les choses.
double tab[5] = {0.0};
double* p = tab + 2; // Ligne A
p[1] = 3.35; // Ligne B
p[-1] = 2.56; // Ligne C
for(int i=0; i < 5; i++)
{
printf("%.02f ", tab[i]);
}
printf("\n");
L’affichage produit est :
0.00 2.56 0.00 3.35 0.00
Ce que nous voyons là est à la fois puissant et dangereux, comme beaucoup de possibilités du langage C.
En ligne A apparait une nouveauté qui relève de ce qu’on appelle l’arithmétique des pointeurs. On peut ajouter ou soustraire un entier à un pointeur et le résultat est un pointeur. Si p est un pointeur sur un type T, et x un entier, alors p + x désigne l’adresse obtenue en ajoutant à x fois sizeof(T) à p. (Et p - x fonctionne de manière similaire.) Ce type de calcul n’a d’intérêt que si p désigne une cellule de tableau. Dans ce cas, p + x désigne la cellule suitée x positions après celle pointée par p (et p - x, x positions avant).
En ligne B, on modifie la cellule p[1], c’est à dire la cellule située une position après la cellule désignée par p, qui lui même pointe la cellule tab[2]. La cellule p[1] est donc la cellule tab[3].
En ligne C, on modifie la cellule p[-1] qui est aussi la cellule tab[1].
Illustrons ceci avec un dessin.

Il y a une subtilité à saisir. p désigne une variable de type double*, alors que tab, le nom du tableau, est une constante de type double*. On peut modifier p, mais on ne peut changer la valeur de tab car la localisation du tableau en mémoire est déterminée lors de sa déclaration et ne peut être modifiée.
La correspondance entre tableaux et pointeurs est spécialement utile pour réaliser des fonctions acceptant des tableaux en paramètres. En effet, le langage C ne permet pas de passer un tableau en argument en copie, mais on peut utiliser des paramètres de types pointeurs pour permettre à une fonction d’accéder à un tableau existant.
Voici le premier exemple qui correspond à un de nos objectifs : réaliser une fonction qui affiche tout ou partie d’un tableau d’entiers.
// Affiche les n premiers éléments du tableau désigné par tab
void printTabInt(int* tab, int n)
{
for(int i=0; i<n; i++)
{
printf("%d ",tab[i]);
}
printf("\n");
}
Cette fonction peut afficher n’importe quel tableau d’entiers désigné par le paramètre tab. Le modificateur const indique que la fonction ne modifie pas le tableau. La valeur de n ne doit en aucun cas excéder la taille du tableau à afficher, et il est impossible de le vérifier dans la fonction car un pointeur sur un tableau ne permet pas de récupérer la taille de ce tableau. Réaliser une fonction à un seul paramètre qui affiche la taille d’un tableau d’entiers quelconque est juste impossible. Voici un exemple d’utilisation.
int main()
{
int t[8] = {2,3,5,7,11};
printTabInt(t,8);
return 0;
}
Le résultat de l’exécution est :
2 3 5 7 11 0 0 0
Exercice de découverte C.dec.x6
Que se passerait-il si on exécutait les lignes de code suivantes ? Tentez de répondre sans utiliser de machine.
int t[8] = {2,3,5,7,11};
printTabInt(t,10);
Le résultat est imprévisible car des emplacements mémoire situés au delà des limites du tableau vont être lus, interprétés comme des entiers, et affichés.
Soit le programme suivant.
void unEssai(int* tab)
{
printf("%ld\n", sizeof(tab));
}
int main()
{
int t[100] = {0};
printf("%ld\n", sizeof(t));
unEssai(t);
return 0;
}
À l’exécution, les valeurs 400 et 8 sont affichées. Pourquoi ? Quelle est l’information donnée par chacune de ces valeurs ?
sizeof(t) donne la taille en octets de la représentation en mémoire du tableau t.
sizeof(tab) donne la taille de le représentation en mémoire du pointeur tab, mais pas celle du tableau pointé. On en déduit que sur la machine ayant été utilisée pour l’expérience, les pointeurs ont une taille en mémoire de 8 octets (64 bits).
Exercice de découverte C.dec.x7
Notre deuxième objectif était de réaliser une fonction réinitialisant à 0 tout ou partie des cellules d’un tableau d’entiers. Voici le squelette d’une telle fonction. Tentez de le compléter à titre d’exercice.
// Met à 0 les n premières cellules du tableau tab
void raz(int* tab, int n)
{
// À compléter
}
void raz(int* tab, int n)
{
for(int i=0; i<n; i++)
{
tab[i] = 0;
}
}
Bonus
| Équivalences de certaines notations. Soustraction de pointeurs. |
|---|
La fonction raz peut être écrite avec une autre notation du type du paramètre désignant un tableau d’entier :
void raz(int tab[], int n)
{
for(int i=0; i<n; i++)
{
tab[i] = 0;
}
}
C’est une différence purement cosmétique, plus lisible dans la mesure où il est explicite que le premier paramètre désigne un tableau d’entiers. Mais ce paramètre est en fait toujours un pointeur sur int et l’utilisation ne change pas.
La correspondance entre pointeur et tableau induit l’équivalence des notations suivantes. Soit tab un tableau ou une variable de type pointeur désignant un tableau. Soit i un entier ou une variable contenant un entier positif ou nul inférieur à la taille du tableau.
tabest équivalent à&(tab[0]).tab[i]est équivalent à*(tab + i).&(tab[i])est équivalent àtab + i.
Il est possible de soustraire deux pointeurs, bien que cela n’ait un intérêt que si les deux pointeurs concernés désignent des cellules d’un même tableau. La différence de deux pointeurs est de type size_t, équivalent à unsigned long.
Exercice de découverte C.dec.x8
Donnez l’affichage produit par l’exécution des lignes suivantes.
int t[100] = {0};
int* p1 = t + 10;
int* p2 = t + 12;
printf("%ld\n", p2-p1);
La valeur 2 est affichée car p2-p1 représente le nombre de données situées entre l’emplacement désigné par p1 et celui désigné par p2.
L’activité est terminée. Vous devez évaluer votre réussite de cette activité par une valeur entre 1 et 4.
- Vous n’avez presque rien compris et échoué à plus de la moitié des exercices de découverte.
- Vous estimez avoir compris une partie des explications et vous avez réussi au moins la moitié des exercices de découverte, mais certaines notions sont encore floues.
- Vous estimez avoir bien compris les explications et vous avez réussi presque tous les exercices de découverte, mais certaines notions abordées étaient nouvelles et vous penser avoir besoin d’un entrainement pour bien les assimiler et être en mesure de les utiliser en pratique.
- Vous connaissiez déjà tout ce qui a été présenté (sauf peut être quelques détails) et il ne sera pas nécessaire que vous reveniez sur ces notions.
Si votre score est 1 ou 2, vous devrez refaire cette activité rapidement, mais après au moins une nuit de sommeil, avant de passer aux activités suivantes. Si votre score est 3 ou 4, vous devez faire les activités suivantes et il ne sera pas nécessaire de revenir sur cette activité, à part pour rechercher des informations utiles pour d’autres activités.
Activité d’entraînement C.ent
Cette activité est essentielle. C’est grâce à elle que vous apprendrez vraiment à comprendre et utiliser les notions vues précédemment. Elle se décompose en plusieurs itérations : ent1, ent2, etc.
Vous devez réaliser au moins une itération et évaluer votre niveau de réussite par une valeur entre 1 et 4 selon les critères habituels. L’itération que vous avez traité le plus récemment est appelée itération courante. On appelle itération suivante celle qui suit l’itération courante, excepté si l’itération courante est la dernière disponible, auquel cas l’itération suivante est la première itération.
Si le résultat est 1, vous devrez traiter à nouveau l’activité de découverte précédente, en laissant passer au moins une nuit, avant de revenir à cette activité d’entraînement en réalisant à nouveau l’itération courante. Vous devez aussi essayer d’identifier les points de blocage et demander à votre enseignant de vous aider à les surmonter.
Si le résultat est 2, vous devrez d’abord comprendre ce qui vous a conduit à des erreurs et / ou ce qui vous a bloqué. Si vous avez des doutes, des difficultés, essayez de trouver les réponses dans les présentations et explication de l’activité de découverte précédente et demandez toute l’aide nécessaire à votre enseignant. Ensuite, vous devrez réaliser l’itération suivante de l’activité d’entraînement actuelle après un délai d’au moins deux jours et d’au plus une semaine.
Si le résultat est 3, vous devrez revenir traiter l’itération suivante après un délai de plusieurs semaines.
En traitant les exercices, vous devrez considérer que les paramètres des fonctions ont des valeurs correctes. Il ne vous est pas demandé de vérifier si certaines valeurs sont aberrantes au regard de ce que demande l’énoncé. Par exemple, si un paramètre doit être positif pour que le traitement demandé soit possible, vous considérerez que la fonction sera appelée avec une valeur positive de ce paramètre.
Vous pouvez utiliser un ordinateur pour tester vos solutions et les corriger en cas de comportement inattendu. C’est même recommandé, à condition de commencer par réfléchir avant de vous jeter sur le clavier. Si vous pensez avoir une solution différente de celle proposée, ce qui peut arriver souvent, vous ne devez en aucun cas rester dans le doute. Vous devez vérifier si votre solution est correcte ou non, soit en testant votre solution avec un ordinateur, soit en demandant à une personne enseignante.
Itération C.ent1
Exercice d’entrainement C.ent1.1
Vous devez réaliser une fonction fillRand qui ne retourne rien et qui accepte un paramètre tab désignant un tableau d’entiers, un paramètre n de type int, et un paramètre k de type int. Cette fonction doit avoir pour effet de remplir les n premières cellules du tableau désigné par tab avec des valeurs pseudoaléatoires comprisent entre 0 (inclus) et k-1 (inclus).
Donnez les lignes de code permettant de créer un tableau de 10 cellules de type int et qui appelle la fonction fillRand pour remplir ce tableau avec des entiers pseudoaléatoires compris entre 0 et 10.
void fillRand(int tab[], int n, int k)
{
// À compléter
}
Il reste à parcourir le tableau et à placer un nombre aléatoire, obtenu par rand()%k, dans chaque cellule.
void fillRand(int tab[], int n, int k)
{
for(int i=0; i<n; i++)
{
tab[i] = rand()%k;
}
}
void main()
{
int t[10];
fillRand(t,10,10);
printTabInt(t,10); // Pour vérification
}
Exercice d’entrainement C.ent1.2
Réalisez une fonction nommée rotG qui accepte un paramètre tab désignant un tableau d’entiers et un paramètre n de type int. En supposant que n soit la taille du tableau, cette fonction doit réaliser une rotation à gauche de toutes les valeurs du tableau. La première valeur doit se retrouver à la fin et chacune des autres décalées d’une position vers la gauche.

Donnez les lignes de code permettant de déclarer un tableau de 7 entiers, initialisé avec les valeurs 1, 2, 3, 4, 5, 6, 7, puis de réaliser une rotation à gauche des 5 valeurs centrales par un appel à la fonction rotG. À l’issue de l’exécution de ces lignes, le tableau devra contenir les valeurs 1, 3, 4, 5, 6, 2, 7.
On s’intéresse d’abord à la fonction rotG. Pour éviter d’écraser une valeur, il faut utiliser une variable dans laquelle on place la première valeur du tableau. On peut ensuite, grâce à une boucle, déplacer une à une les autres valeurs. Attention au nombre d’itérations de la boucle et aux valeurs initiale et finale de la variable qui contrôle cette boucle. À l’issue de l’exécution de la boucle, la valeur sauvegardée doit être placée dans le dernière cellule du tableau.
Voici le détail de la fonction rotG.
void rotG(int tab[], int n)
{
int valGauche = tab[0];
for(int i=0; i<n-1; i++)
{
tab[i] = tab[i+1];
}
tab[n-1] = valGauche;
}
Il reste à écrire le code permettant de réaliser une rotation des cellules d’indice 1 à 5 du tableau suivant.
int t[] = {1,2,3,4,5,6,7};
La fonction rotG est définie dans l’indice précédent. Le code demandé est le suivant.
int t[] = {1,2,3,4,5,6,7};
rotG(t+1,5);
printTabInt(t,7); // Pour vérification
La fonction d’affichage printTabInt est celle donnée dans l’activité de découverte. Elle permet, si vous travaillez sur machine, de tester la solution proposée.
Exercice d’entrainement C.ent1.3
Que fait la fonction suivante ?
void exg(int* p, int*q)
{
int tmp = *p;
*p = *q;
*q = tmp;
}
Elle échange les valeurs situées aux emplacement mémoire pointés par p et q.
Complétez la fonction suivante de manière à ce qu’elle ait pour effet de réorganiser les éléments situés dans les n premières cellules du tableau désigné par tab en faisant en sorte que la plus petite valeur apparaisse en première position. Toutes les autres valeurs peuvent changer de place, leurs positions ne sont pas critiques. Par contre aucune valeur ne doit être perdue. À l’ordre des valeurs près, le contenu du tableau ne doit pas changer.
Si par exemple n vaut 6 et que le tableau contient les valeurs 5, 6, 3, 4, 9, 3, alors une des valeurs 3 doit se retrouver au début mais toutes les autres valeurs peuvent changer de place, dès lors qu’elles restent dans le tableau. Vous devez utiliser la fonction exg.
void metMinAuDebut(int tab[], int n)
{
for(int i=1; i<n; i++)
{
if(t[0] > t[i])
{
// À compléter
}
}
}
La ligne à compléter est :
exg(tab, tab+i);
Mais elle pourrait aussi s’écrire, de manière strictement équivalente :
exg(&(tab[0]), &(tab[i]);
Vous devez maintenant compléter la fonction suivante…
void triTabInt(int tab[], int n)
{
// À compléter
}
…de manière à ce qu’elle ait pour effet de trier en ordre croissant les n premières valeurs du tableau désigné par tab. Vous devez utiliser une boucle dans le corps de laquelle il y a un appel à la fonction metMinAuDebut. Le principe à appliquer est le suivant :
- On imagine que le tableau est constitué de deux parties : une partie triée, initialement vide, et le reste du tableau qui ne contient aucune valeur plus petite que celles situées dans la partie triée.
- À chaque itération, on ajoute une valeur à la partie triée.

void triTabInt(int tab[], int n)
{
for(int i=0; i < n-1; i++)
{
// À compléter
}
}
La partie à compléter comporte juste un appel à la fonction metMinAuDebut. La difficulté est de trouver les valeurs à passer en paramètres à cette fonction. (C’est à dire, pour utiliser un langage plus rigoureux, les arguments de l’appel de la fonction.)
void triTabInt(int tab[], int n)
{
for(int i=0; i < n-1; i++)
{
metMinAuDebut(tab+i, n-i);
}
}
Si celle solution n’est pas claire pour vous, identifiez bien ce qui vous pose problème : l’aspect algorithmique ou bien l’argument tab+i ? Dans le premier cas, prenez le temps de simuler à la main les première étapes. Dans le deuxième cas, réétudiez les parties présentant les tableaux et la correspondance entre tableaux et pointeurs dans l’activité de découverte précédente. Finalement, en langage C, un tableau n’est rien d’autre qu’une suite de données contigües en mémoire. La notation int tab[] ne désigne rien d’autre qu’un paramètre de type pointeur qui n’est pas obligé de pointer le début d’un tableau, mais qui peut pointer plus loin dans le tableau. La partie non triée peut être vue comme un tableau à part entière.
Itération C.ent2
Exercice d’entrainement C.ent2.1
Réalisez une fonction nommée isIn qui accepte un paramètre tab désignant un tableau d’entiers, un
paramètre n de type int, et un troisième paramètre val de type int. En supposant que n soit au plus égal à la taille du tableau, cette fonction doit retourner un entier non nul (représentant le Booléen true) si val est dans les n premières cellules de tab, et doit retourner 0 (false) dans le cas contraire.
int isIn(int tab[], int n, int val)
{
// À compléter
}
Il reste à parcourir le tableau et comparer la valeur de chaque cellule avec val. Si une cellule égale à val est trouvée, on retourne directement la valeur 1. Si la boucle parcourt tout le tableau sans trouver val, la fonction retourne 0.
int isIn(int tab[], int n, int val)
{
for(int i=0; i<n; i++)
{
if(tab[i] == val) return 1;
}
return 0;
}
Exercice d’entrainement C.ent2.2
Réalisez une fonction…
void minMaxTab(int tab[], int n, int* min, int* max)
…permettant de rechercher la plus petite et la plus grande valeur d’un tableau. Le paramètre tab désigne le tableau et n donne sa taille. Les paramètres min et max doivent pointer des variables, situées à l’extérieur de la fonction, dans lesquelles les résultats doivent être placés. On suppose que le tableau comporte au moins une cellule. Voici un exemple de fonction main permettant de tester la fonction à réaliser. Vous devez compléter cette fonction main avant de continuer l’exercice.
int main()
{
int t[] = {2,5,3,7,1,8,2,3};
int mini; int maxi;
minMaxTab(/* À compléter */); // ligne A
printf("minimum = %d, maximum = %d\n", mini, maxi);
return 0;
}
La ligne A de la fonction main doit être :
minMaxTab(t, 8, &mini, &maxi);
Il faut passer en paramètres les adresses des variables mini et maxi dans lesquelles la fonction placera son résultat. Dans la fonction, les contenus de ces variables seront accessibles en utilisant les notations *min et *max.
void minMaxTab(int tab[], int n, int* min, int* max)
{
*min = tab[0];
*max = tab[0];
for(int i=1; i<n; i++)
{
// À compléter
}
}
Il faut bien comprendre que *min et *max désignent les variables, situées à l’extérieur de la fonction, dans lesquelles la plus petite et la plus grande valeur du tableau seront placées. Mais rien ne nous empêche d’utiliser ces variables pour y placer des résultats intermédiaires. On commence par y mettre la première valeur du tableau. Il reste à parcourir les cellules restantes et à mettre à jour *min et *max à chaque fois qu’une valeur plus petite que *min ou qu’une valeur plus grande que *max est trouvée.
Voici une version complète de la fonction minMaxTab.
void minMaxTab(int tab[], int n, int* min, int* max)
{
*min = tab[0];
*max = tab[0];
for(int i=1; i<n; i++)
{
if(tab[i] < *min) *min = tab[i];
else if(tab[i] > *max) *max = tab[i];
}
}
Des variantes sont possibles. Par exemple, on pourrait utiliser des variables de type int pour la recherche de la plus petite et de la plus grande valeur, et ne placer les résultat dans *min et *max qu’à l’issue de la recherche. On pourrait aussi utiliser deux boucles successives, une pour rechercher la plus petite valeur et une autre pour rechercher la plus grande. Si votre solution est différente de celle proposée, il est important que vous la testiez sur machine ou, si vous participer à un enseignement en présence, que vous demandiez à votre enseignant ou votre enseignante de la vérifier.
Exercice d’entrainement C.ent2.3
On veut maintenant réaliser une fonction fusion…
void fusion(const double t1[], int n1, const double t2[],
int n2, double t[])
…qui admet en paramètre :
- un tableau de
doubledésigné part1, de longueur au moins égale àn1, dont les valeurs sont supposées être triées en ordre croissant, - un tableau de
doubledésigné part2, de longueur au moins égale àn2, dont les valeurs sont supposées être triées en ordre croissant, - un tableau de
doubledésigné part, de longueur au moins égale àn1+n2, dont le contenu n’est pas important car il sera écrasé.
Le rôle de cette fonction est de placer dans le tableau désigné par t la fusion des deux parties précédemment triées du tableau désigné par t. Cette fusion est une suite croissante de n valeurs : on fusionne deux tableaux triés en un seul tableaux trié.
Voici, à titre d’exemple, les premières étapes de la fusion de 3, 5, 6 et de 3, 4, 9. Les petites flèches indiquent les positions de deux curseurs permettant de parcourir chacune des deux listes à fusionner. Un tiret sous une valeur indique qu’elle a déjà été ajoutée à la fusion.
Partie 1 Partie 2 Fusion
Étape 1 3 5 6 3 4 9
^ ^
Étape 2 3 5 6 3 4 9 3
- ^ ^
Étape 3 3 5 6 3 4 9 3 3
- ^ - ^
Étape 4 3 5 6 3 4 9 3 3 4
- ^ - - ^
Étape 5 3 5 6 3 4 9 3 3 4 5
- - ^ - - ^
Étape 6 3 5 6 3 4 9 3 3 4 5 6
- - - ^ - - ^
Étape 7 3 5 6 3 4 9 3 3 4 5 6 9
- - - ^ - - - ^
Lorsque l’opération de fusion est terminée, le résultat doit être recopié dans le tableau désigné par t.
Voici une version partielle de la fonction, à compléter.
void fusion(const double t1[], int n1, const double t2[],
int n2, double t[])
{
int i1 = 0; // Position dans t1
int i2 = 0; // Position dans t2
for(int i=0; i < n1+n2; i++)
{
// À compléter
}
}
À chaque itération de la boucle, une valeur de t1 ou une valeur de t2 doit être ajoutée à t en position i.
La fonction main suivante donne un exemple de mise en oeuvre de la fonction fusion.
int main()
{
double t1[] = {3,5,6};
double t2[] = {3,4,9};
double t[6];
fusion(t1, 3, t2, 3, t);
for(int i=0; i<6; i++)
{
printf("%.02f ", t[i]);
}
printf("\n");
return 0;
}
Si la fonction fusion est correctement programmée, l’affichage produit est :
3.00 3.00 4.00 5.00 6.00 9.00
Voici un code un peu plus complet.
void fusion(const double t1[], int n1, const double t2[],
int n2, double t[])
{
int i1 = 0; // Position dans t1
int i2 = 0; // Position dans t2
for(int i=0; i < n1+n2; i++)
{
if(i1 >= n1)
{
// À compléter Ligne A
}
else if(i2 >= n2)
{
// À compléter Ligne B
}
else if(t1[i1] < t2[i2])
{
// À compléter Ligne C
}
else
{
// À compléter Ligne D
}
}
printf("\n");
}
La ligne A gère le cas où tous les éléments du tableau désigné par t1 ont été consommés. la ligne 2 gère le cas où se sont tous les éléments du tableau désigné par t2 qui ont été consommés. Les lignes C et D concernent les cas où il reste des valeurs dans les deux tableaux à fusionner et où il faut consommer un élément d’un des deux tableaux.
void fusion(const double t1[], int n1, const double t2[],
int n2, double t[])
{
int i1 = 0; // Position dans t1
int i2 = 0; // Position dans t2
for(int i=0; i < n1+n2; i++)
{
if(i1 >= n1)
{
t[i] = t2[i2]; i2++;
}
else if(i2 >= n2)
{
t[i] = t1[i1]; i1++;
}
else if(t1[i1] < t2[i2])
{
t[i] = t1[i1]; i1++;
}
else
{
t[i] = t2[i2]; i2++;
}
}
printf("\n");
}
Itération C.ent3
Exercice d’entrainement C.ent3.1
Réalisez une fonction nommée sumTab qui accepte un paramètre tab désignant un tableau d’entiers, et
paramètre n de type int. En supposant que n soit la taille du tableau, cette fonction doit retourner un la somme des valeurs du tableau.
int sumTab(int tab[], int n)
{
int sum = 0;
// À compléter
}
Il reste à parcourir le tableau et ajouter la valeur de chaque cellule à la variable sum, qui sera retournée après l’exécution de la boucle.
int sumTab(int tab[], int n)
{
int sum = 0;
for(int i=0; i<n; i++)
{
sum = sum + tab[i];
}
return sum;
}
Exercice d’entrainement C.ent3.2
Réalisez une fonction…
int valeursPaires(int tab[], int n, int pairs[])
…permettant de collecter dans le tableau désigné par pairs toutes les valeurs paires situées dans les n premières cellules du tableau désigné par tab. On suppose que le tableau désigné par tab et que celui désigné par pairs ont une taille au moins égale à n. La fonction retourne le nombre de valeurs paires récupérées.
Voici un exemple de fonction main permettant de tester la fonction à réaliser. Vous devez compléter cette fonction main et déterminer ce qu’elle doit afficher avant de continuer l’exercice.
int main()
{
int t[] = {2,5,3,7,1,8,2,3};
int collect[8];
int nPairs = // À compléter
printTabInt(collect, nPairs); // Pour vérification
return 0;
}
La ligne à compéter est :
int nPairs = valeursPaires(t, 8, collect);
Les valeurs affichées sont 2 8 2.
Il vous reste à définir la fonction valeurspaires. Vous pourrez utiliser deux variables, une pour parcourir les indices du tableau à parcourir, et l’autre, initialisée à 0, pour désigner l’indice de la prochaine valeur à placer dans le tableau destiné à collecter les valeurs paires.
Voici une version à compléter de la fonction à définir.
int valeursPaires(int tab[], int n, int pairs[])
{
int k = 0;
for(int i=0; i<n; i++)
{
// À compléter
}
return k;
}
int valeursPaires(int tab[], int n, int pairs[])
{
int k = 0;
for(int i=0; i<n; i++)
{
if(tab[i]%2 == 0)
{
pairs[k] = tab[i];
k++;
}
}
return k;
}
Comme toujours, votre solution peut être différente sans pour autant être incorrecte, mais vous devez lever rapidement tout incertitude. Valider une solution incorrecte est néfaste à un bon apprentissage.
Exercice d’entrainement C.ent3.3
Le triangle de Pascal est construit avec les règles suivantes :
- La première ligne comporte juste la valeur 1.
- Chaque ligne suivante commence par 1, puis comporte les sommes de deux valeurs consécutives de la ligne précédente, puis se termine par 1.
ligne 1 : 1
ligne 2 : 1 1
ligne 3 : 1 2 1
ligne 4 : 1 3 3 1
ligne 5 : 1 4 6 4 1
...
Vous devez définir une fonction…
int getPascal(int ligne[], int k)
… qui permet de récupérer dans le tableau désigné par ligne la ligne k du triangle de Pascal. On suppose que la taille du tableau est suffisante pour contenir toutes les valeurs de la ligne à produire. La valeur de retour est le nombre de valeurs de la ligne produite.
Voici un exemple de fonction main permettant de tester la fonction getPascal.
int main()
{
int tab[10];
int n = getPascal(tab, 5);
printTabInt(tab,5);
return 0;
}
L’affichage attendu étant :
1 4 6 4 1
Le principe du calcul est le suivant. Les lignes sont numérotées 1, 2, 3, etc., conformément à l’illustration du triangle de Pascal donnée précédemment. Pour tout \(i\) au moins égal à 1, chaque ligne \(i\) comporte \(i\) valeurs qui sont stockées dans les cellules d’indice 0 à \(i-1\) d’un tableau.
Voici un squelette de la définition de la fonction.
int getPascal(int ligne[], int k)
{
// Tableau pour stocker temporairement chaque nouvelle ligne calculée
int nouvelleLigne[k];
// Définition de la première ligne du triangle
nouvelleLigne[0] = 1;
// Calcul des lignes suivantes jusqu'à la ligne k
for(int i=2; i <= k; i++)
{
// Calcul de la ligne i d'après les valeurs de la ligne précédente
// situées dans le tableau ligne. Les valeurs de la ligne i sont
// placées dans le tableau nouvelleLigne.
// Recopie des valeurs de la ligne i dans le tableau ligne.
}
}
On ne stocke pas toutes les lignes du triangle. (D’ailleurs nous n’avons pas encore introduit les tableaux à 2 dimensions.) Deux tableaux sont utilisés : ligne, qui contient la dernière ligne produite, et nouvelleLigne, dans lequel on place les valeurs de la ligne en cours de calcul. Lorsque le calcul d’une nouvelle ligne est terminé, on recopie ses valeurs dans le tableau ligne.
Voici une version encore incomplète. Veillez à ne pas confondre les variables i et j. La variable i désigne la ligne en cours de calcul. La variable j désigne la position dans la ligne en cours de calcul de la valeur en cours de calcul.
int getPascal(int ligne[], int k)
{
int nouvelleLigne[k];
nouvelleLigne[0] = 1;
for(int i=2; i <= k; i++)
{// Production de la ligne i dans le tableau nouvelleLigne.
nouvelleLigne[0] = 1;
for(int j=1; j <= i-2; j++)
{
// Calcul d'une valeur de la nouvelle ligne
// À compléter
}
nouvelleLigne[i-1] = 1;
// Recopie le la ligne i dans le tableau ligne.
for(int j=0; j < i; j++)
{
// À compléter
}
}
}
int getPascal(int ligne[], int k)
{
int nouvelleLigne[k];
nouvelleLigne[0] = 1;
for(int i=2; i <= k; i++)
{// Production de la ligne i dans le tableau nouvelleLigne.
nouvelleLigne[0] = 1;
for(int j=1; j <= i-2; j++)
{
nouvelleLigne[j] = ligne[j-1] + ligne[j];
}
nouvelleLigne[i-1] = 1;
// Recopie le la ligne i dans le tableau ligne.
for(int j=0; j < i; j++)
{
ligne[j] = nouvelleLigne[j];
}
}
}
Activité de consolidation C.top
Réaliser cette activité consiste à traiter un des exercices de consolidation proposés. Si vous réalisez plusieurs fois cette activité, laissez passer au moins une semaine entre chaque itération et traitez à chaque fois un exercice différent.
Exercice de consolidation C.top1
Supposons que nous disposions d’une fonction…
void triTab(double tab[], int n)
… qui trie en ordre croissant les n premières valeurs du tableau désigné par tab .
Complétez la fonction suivante…
void biTri(double t[], int n, int m)
…de manière à ce qu’elle ait l’effet suivant :
On considère que la tableau désigné par t est constitué de deux parties. La première partie comporte les m premières valeurs et la seconde partie les valeurs suivantes. L’exécution de biTri doit trier chacune de ces deux parties. On suppose que m est compris entre 0 et n. Voici un exemple dans le quel n vaut 6 et m vaut 3. Les deux tris doivent être réalisés par des appels à la fonction triTab.

void biTri(double t[], int n, int m)
{
triTab(t,m);
triTab(t+m, n-m);
}
La fonction fusion définie dans l’exercice C.ent2.3 permet de fusionner deux listes déjà triées, représentées par des tableaux de double, et de placer le résultat, qui est une liste triée comportant tous les éléments des listes initiales, dans un tableau de double.
On considère ici que cette fonction fusion est déjà correctement programmée.
void fusion(const double t1[], int n1, const double t2[],
int n2, double t[])
L’une des listes à fusionner est constituée des n1 premiers éléments du tableau désigné par t1. L’autre est constituée des n2 premiers éléments du tableau désigné par t2. Le résultat est constitué des n1+n2 premiers éléments du tableau désigné par tab. Si vous souhaitez faire des essais sur machine, vous pouvez reprendre le code de cette fonction donné en solution de l’exercice C.ent2.3.
En utilisant la fonction fusion, vous devez réaliser une fonction récursive nommée triFusion permettant de trier les n premiers éléments d’un tableau de double nommé t.
void triFusion(double t[], int n)
Le principe est le suivant :
- Si la liste à trier a au plus un élément, alors elle est déjà triée et il n’y a rien de particulier à faire.
- Sinon, cette liste est séparée en 2 parties de tailles similaires qui sont triées séparément par des appels récursifs à la fonction
triFusion, puis les résultats sont fusionnés en une seule liste.
Voici un schéma détaillant les étapes d’un tri fusion.

Votre mission consiste à compléter la définition de triFusion donnée ci-dessous.
void triFusion(double t[], int n)
{
if(n <= 1) return;
int m = n / 2;
double tabTmp[n];
// Appels récurfifs
fusion(/* À compléter */);
for(int i=0; i<n; i++) // Ligne A
{
t[i] = tabTmp[i];
} // Ligne B
}
La partie située entre le ligne A et la ligne B permet de recopier le résultat du tri dans le tableau qui contenait initialement les valeurs à trier. Cela n’a rien d’anecdotique. Si le résultat de la fusion n’était pas placé dans un tableau intermédiaire avant d’être recopié dans le tableau d’origine, des valeurs seraient écrasées avant d’être exploitées pour la fusion et le tri échouerait.
Voici un exemple d’utilisation de la fonction.
int main()
{
double tab[] = {5,6,3,4,9,3};
triFusion(tab,6);
for(int i=0; i<6; i++)
{
printf("%.02f ", tab[i]);
}
printf("\n");
return 0;
}
Voici une version avec les appels récursifs.
void triFusion(double t[], int n)
{
if(n <= 1) return;
int m = n / 2;
double tabTmp[n];
triFusion(t,m);
triFusion(t+m,n-m);
fusion(/* À compléter */);
for(int i=0; i<n; i++) // Ligne A
{
t[i] = tabTmp[i];
} // Ligne B
}
void triFusion(double t[], int n)
{
if(n <= 1) return;
int m = n / 2;
double tabTmp[n];
triFusion(t,m);
triFusion(t+m,n-m);
fusion(t,m,t+m,n-m,tabTmp);
for(int i=0; i<n; i++)
{
t[i] = tabTmp[i];
}
}
Exercice de consolidation C.top2
Le but de cet exercice est de réaliser une fonction permettant de calculer efficacement le nombre maximum d’occurrences d’une valeur dans un tableau de valeurs de type uint8_t. Prenons un exemple. Si le tableau à analyser contient les valeurs…
1, 2, 3, 5, 6, 1, 2, 4, 5, 9, 45, 25, 12, 5, 3
… alors le nombre maximum d’occurrence d’une valeur est 3. En effet, la valeur 5 apparait trois fois et aucune autre valeur n’apparait plus souvent.
Une solution serait de parcourir le tableau à l’aide d’une boucle et, pour chaque valeur trouvée, de compter son nombre d’occurrences à l’aide d’une seconde boucle. Mais cela nécessite d’utiliser une boucle imbriquée dans une autre, avec pour conséquence un temps d’exécution proportionnel au carré de la taille du tableau à analyser.
Le challenge proposé ici est de réaliser un programme ne comportant pas de boucles imbriquées, mais un nombre limité de boucles successives, qui produit l’information recherchée en temps linéaire. En contrepartie d’une exécution rapide, la fonction à réaliser devra utiliser un tableau temporaire (local) d’entiers comportant 256 cellules.
int maxFrequ(uint8_t tab[], int n)
{
int compteurs[256] = {0};
// À compléter
int maxOcc = 0;
// À compléter
return maxOcc;
}
Le tableau compteurs doit contenir, après exécution de la première partie à compléter, le nombre d’occurrences de chaque valeur comprise entre 0 et 255 dans le tableau tab : compteurs[0] doit contenir le nombre d’occurrence de la valeur 0 dans tab, compteurs[1] doit contenir le nombre d’occurrence de la valeur 1 dans tab, etc.
La deuxième partie à compléter doit rechercher la plus grande valeur du tableau compteurs.
int maxFrequ(uint8_t tab[], int n)
{
int compteurs[256] = {0};
for(int i=0; i<n; i++)
{
compteurs[tab[i]]++;
}
int maxOcc = 0;
for(int i=0; i<256; i++)
{
if(compteurs[i] > maxOcc)
{
maxOcc = compteurs[i];
}
}
return maxOcc;
}