{"id":44,"date":"2022-01-03T18:58:33","date_gmt":"2022-01-03T18:58:33","guid":{"rendered":"https:\/\/9h15.net\/activ\/?p=44"},"modified":"2022-02-02T20:25:24","modified_gmt":"2022-02-02T20:25:24","slug":"c-et-c-partie-c","status":"publish","type":"post","link":"https:\/\/9h15.net\/activ\/c-et-c-partie-c\/","title":{"rendered":"C et C++ partie C"},"content":{"rendered":"<p><code>Par O. Bailleux, Ma\u00eetre de conf\u00e9rences HDR \u00e0 l'universit\u00e9 de Bourgogne.<\/code><\/p>\n<h1><a id=\"tableaux-et-pointeurs\" class=\"anchor\" aria-hidden=\"true\"><\/a>Tableaux et pointeurs<\/h1>\n<p>Les activit\u00e9s <strong>#.dec<\/strong> (<strong>dec<\/strong> pour D\u00e9couverte) consistent \u00e0 \u00e9tudier des <strong>pr\u00e9sentations explicatives<\/strong> et \u00e0 traiter tous les <strong>exercices de d\u00e9couverte<\/strong> propos\u00e9s. Si vous ne r\u00e9pondez pas correctement \u00e0 un exercice de d\u00e9couverte, revenez en arri\u00e8re pour relire les explications et identifier la cause de votre erreur.<\/p>\n<p>Les activit\u00e9s <strong>#.ent<\/strong> (<strong>ent<\/strong> pour Entrainement) consistent \u00e0 traiter des <strong>exercices d&rsquo;entra\u00eenement<\/strong>. Vous devez d&rsquo;abord tenter de traiter ces exercices sans d\u00e9voiler d&rsquo;indice ni regarder la solution. Vous pouvez remonter dans le document pour relire certaines explications ou consulter les solutions des exercices de d\u00e9couverte ou d&rsquo;entra\u00eenement pr\u00e9c\u00e9demment trait\u00e9s.<\/p>\n<h2><a id=\"activit%C3%A9-de-d%C3%A9couverte-c-dec\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 de d\u00e9couverte C.dec<\/h2>\n<h3><a id=\"c-dec1-pointeur-et-param%C3%A8tres-de-type-pointeur\" class=\"anchor\" aria-hidden=\"true\"><\/a>C.dec1 : Pointeur et param\u00e8tres de type pointeur<\/h3>\n<h4><a id=\"pr%C3%A9requis\" class=\"anchor\" aria-hidden=\"true\"><\/a>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Partie A et types entiers d\u00e9crits dans la partie B.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4><a id=\"objectif\" class=\"anchor\" aria-hidden=\"true\"><\/a>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>R\u00e9aliser une fonction qui modifie des variables situ\u00e9es n&rsquo;importe o\u00f9 dans le programme.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Prenons un exemple pour introduire notre objectif. Examinons la fonction suivante.<\/p>\n<pre><code class=\"language-c\">void test()\n{\n  int a = rand()%10;              \/\/ Bloc A\n  int b = rand()%10;\n  \n  if(a&gt;b)                         \/\/ Bloc B\n  {\n    int tmp = a; a = b; b = tmp;  \n  }\n  \n  printf(\"%d %d\\n\",a,b);\n}\n<\/code><\/pre>\n<p>Quel est l&rsquo;effet de l&rsquo;ex\u00e9cution de cette fonction ? Tentez de r\u00e9pondre sans utiliser d&rsquo;ordinateur.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>L&rsquo;affichage d&rsquo;une suite croissante de deux valeurs al\u00e9atoires comprises entre 0 et 9.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p>Le principe consiste produire deux valeurs al\u00e9atoire plac\u00e9es dans les variables <code>a<\/code> et <code>b<\/code>, puis, si la premi\u00e8re valeur est plus grande que la deuxi\u00e8me, \u00e0 \u00e9changer les contenus des deux variables. Cette op\u00e9ration de tri des deux valeurs est r\u00e9alis\u00e9e par le bloc B.<\/p>\n<p>On souhaite <strong>d\u00e9l\u00e9guer<\/strong> cette op\u00e9ration de remise en ordre des valeurs de <code>a<\/code> et <code>b<\/code> \u00e0 une fonction nomm\u00e9e <code>reorder<\/code>. Si on proc\u00e8de de la mani\u00e8re suivante,&#8230;<\/p>\n<pre><code class=\"language-c\">void reorder(int a, int b)\n{\n  if(a&gt;b)                         \n  {\n    int tmp = a; a = b; b = tmp;  \n  }\n}\n\nvoid test()\n{\n  int a = rand()%10;       \n  int b = rand()%10;\n  reorder(a,b);\n  printf(\"%d %d\\n\",a,b);\n}\n<\/code><\/pre>\n<p>&#8230;\u00e7a ne fonctionne pas. Si on fait des affichages de <code>a<\/code> et <code>b<\/code> avant et apr\u00e8s appel \u00e0 <code>reorder<\/code>, on constate que l&rsquo;appel de cette fonction n&rsquo;a strictement aucun effet sur les variables <code>a<\/code> et <code>b<\/code>.<\/p>\n<p>Pour comprendre exactement pourquoi, il faut faire un dessin de ce qui se passe en m\u00e9moire \u00e0 la fin de l&rsquo;ex\u00e9cution de <code>reorder<\/code> appel\u00e9e par <code>test<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/1.png\" alt=\"\" \/><\/p>\n<p>Tout ce qui est repr\u00e9sent\u00e9 par cette illustration se situe dans une zone m\u00e9moire appel\u00e9e <strong>pile d&rsquo;ex\u00e9cution<\/strong>, ou simplement <strong>pile<\/strong>, dans laquelle sont stock\u00e9s les contenus de toutes les variables locales, aussi appel\u00e9es variables automatiques, c&rsquo;est \u00e0 dire les variables d\u00e9clar\u00e9es \u00e0 l&rsquo;int\u00e9rieur du corps d&rsquo;une fonction.<\/p>\n<p>On y voit les deux variables de la fonction test, en supposant qu&rsquo;elles aient re\u00e7u respectivement les valeurs 7 et 4. Ces variables n&rsquo;existent que pendant l&rsquo;ex\u00e9cution de la fonction dans laquelle elles sont d\u00e9clar\u00e9es.<\/p>\n<p>Lors de l&rsquo;appel de <code>reorder<\/code>, les valeurs des variables <code>a<\/code> et <code>b<\/code> de test sont <strong>copi\u00e9es<\/strong> dans les param\u00e8tres de la fonction <code>reorder<\/code>, qui sont des variables locales de cette fonction.<\/p>\n<blockquote><p>Retenez bien ceci : les param\u00e8tres d&rsquo;une fonction sont des variables locales \u00e0 part enti\u00e8re, qui sont initialis\u00e9es avec les valeurs pass\u00e9es en arguments (on dit parfois aussi pass\u00e9s en param\u00e8tres) lors de l&rsquo;appel de la fonction.<\/p><\/blockquote>\n<p>L&rsquo;ex\u00e9cution de la fonction <code>reorder<\/code> a pour effet d&rsquo;\u00e9changer les contenus de ses deux variables locales <code>a<\/code> et <code>b<\/code>, mais ceci n&rsquo;a aucun effet sur les variables de la fonction <code>test<\/code>. En r\u00e9sum\u00e9, une fonction appel\u00e9e par des variables en argument va travailler avec des <strong>copies<\/strong> des valeurs de ces variables. C&rsquo;est d&rsquo;ailleurs souhaitable dans beaucoup de situation car cela \u00e9vite les <strong>effets de bord<\/strong>, c&rsquo;est \u00e0 dire la modification par une fonction d&rsquo;une variable ext\u00e9rieure \u00e0 cette fonction.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Utiliser des pointeurs<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Il arrive qu&rsquo;on souhaite qu&rsquo;une fonction puisse modifier des variables qui lui sont ext\u00e9rieure. Dans ce cas on peut utiliser des pointeurs. <strong>Un pointeur est une adresse m\u00e9moire<\/strong> \u00e0 laquelle se trouve une donn\u00e9e, telle que par exemple le contenu d&rsquo;une variable. Il est possible d&rsquo;utiliser des variables de type pointeur, c&rsquo;est \u00e0 dire des variables qui contiennent des adresses m\u00e9moire.<\/p>\n<p>Reprenons l&rsquo;exemple pr\u00e9c\u00e9dent avec une impl\u00e9mentation qui fonctionne gr\u00e2ces \u00e0 des pointeurs.<\/p>\n<pre><code class=\"language-c\">void reorder(int* p, int* q)          \/\/ Ligne A\n{\n  if(*p &gt; *q)                         \/\/ Ligne B\n  {\n    int tmp = *p; *p = *q; *q = tmp;  \/\/ Ligne C\n  }\n}\n\nvoid test()\n{\n  int a = rand()%10;       \n  int b = rand()%10;\n  reorder(&amp;a, &amp;b);                    \/\/ Ligne D\n  printf(\"%d %d\\n\",a,b);\n}\n<\/code><\/pre>\n<p>Il y a trois nouvelles notations qui apparaissent ici, et il faut prendre le temps de les expliquer. Dans toutes la suite de l&rsquo;enseignement, ces notations seront tr\u00e8s souvent utilis\u00e9es. Si vous les confondez, vous ferez des erreurs.<\/p>\n<p><strong>En ligne A<\/strong>, les param\u00e8tre de la fonction <code>reorder<\/code> sont de type <code>int*<\/code>, c&rsquo;est \u00e0 dire pointeur sur <code>int<\/code>. Ces param\u00e8tres doivent recevoir des adresses m\u00e9moires auxquelles se trouvent des donn\u00e9es de type <code>int<\/code>.<\/p>\n<p><strong>En ligne B<\/strong>, la notation <code>*p<\/code> d\u00e9signe la donn\u00e9e point\u00e9e par <code>p<\/code>, c&rsquo;est \u00e0 dire la donn\u00e9e de type <code>int<\/code> situ\u00e9e en m\u00e9moire \u00e0 l&rsquo;adresse contenue dans la variable <code>p<\/code>. La condition de l&rsquo;instruction <code>if<\/code> ne compare pas les adresses, mais les <strong>valeurs point\u00e9es<\/strong> par les adresses qui ont \u00e9t\u00e9 transmises en arguments et qui sont contenues dans les param\u00e8tres <code>p<\/code> et <code>q<\/code>.<\/p>\n<p><strong>En ligne C<\/strong>, on \u00e9change les valeurs point\u00e9es par les param\u00e8tres <code>p<\/code> et <code>q<\/code>.<\/p>\n<p><strong>En ligne D<\/strong>, la notation <code>&amp;a<\/code> d\u00e9signe l&rsquo;adresse m\u00e9moire de la variable locale <code>a<\/code>. Ce sont donc les pointeurs sur <code>a<\/code> et <code>b<\/code> qui sont transmis en argument \u00e0 la fonction <code>reorder<\/code>.<\/p>\n<p>Un nouveau dessin montre ce qui se passe en m\u00e9moire \u00e0 la fin de l&rsquo;ex\u00e9cution de <code>reorder<\/code> appel\u00e9e par <code>test<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/2.png\" alt=\"image-20211220190446731\" \/><\/p>\n<p>On aurait tout aussi bien pu appeler les param\u00e8tres de <code>reorder<\/code> <code>a<\/code> et <code>b<\/code>, plutot que <code>p<\/code> et <code>q<\/code>. Le changement de nom a pour seul but une meilleure lisibilit\u00e9. Maintenant, le programme fonctionne parfaitement.<\/p>\n<p>Revenons sur les trois nouvelles notations.<\/p>\n<ul>\n<li><code>int*<\/code> repr\u00e9sente le type pointeur sur <code>int<\/code>. tous les types peuvent \u00eatre point\u00e9s. On peut utiliser des pointeurs sur <code>double<\/code>, <code>char<\/code>, etc., not\u00e9s <code>double*<\/code>, <code>char*<\/code>, etc. On peut aussi utiliser des pointeurs sur des pointeurs. Par exemple le type <code>int**<\/code> repr\u00e9sente l&rsquo;adresse m\u00e9moire d&rsquo;une variable de type <code>int*<\/code>, donc l&rsquo;adresse d&rsquo;une variable contenant l&rsquo;adresse d&rsquo;une variable contenant un entier.<\/li>\n<li>Si <code>x<\/code> est une variable alors la notation <code>&amp;x<\/code> repr\u00e9sente l&rsquo;<strong>adresse<\/strong> de <code>x<\/code>, de type pointeur sur le type de <code>x<\/code>.<\/li>\n<li>Si <code>x<\/code> est un pointeur ou une variable de type pointeur, <code>*x<\/code> repr\u00e9sente <strong>la donn\u00e9e point\u00e9e<\/strong> par <code>x<\/code>.<\/li>\n<\/ul>\n<p>Notez au passage que le symbole <code>*<\/code> a deux usages diff\u00e9rents, i.e. construire un type pointeur ou d\u00e9signer la donn\u00e9e point\u00e9e par un pointeur, en plus de son utilisation arithm\u00e9tique comme symbole de multiplication. C&rsquo;est le contexte qui permet au compilateur et \u00e0 l&rsquo;informaticienne ou l&rsquo;informaticien de d\u00e9terminer la signification de ce symbole.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-c-dec-x1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte C.dec.x1<\/h5>\n<p>Quelle est la valeur de <code>x<\/code> apr\u00e8s l&rsquo;ex\u00e9cution de ces lignes de code ?<\/p>\n<pre><code class=\"language-c\">int x = 10;\nint* p = &amp;x;\n*p = *p + 1;\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>11<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-c-dec-x2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte C.dec.x2<\/h5>\n<p>Quelle est la valeur de <code>x<\/code> apr\u00e8s l&rsquo;ex\u00e9cution de ces lignes de code ?<\/p>\n<pre><code class=\"language-c\">int x = 10;\nint* p = &amp;x;\np = p + 1;\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>10, car la valeur point\u00e9e par <code>p<\/code> n&rsquo;a jamais \u00e9t\u00e9 modifi\u00e9e. Par contre le contenu de <code>p<\/code> a \u00e9t\u00e9 modifi\u00e9, sans effet sur <code>x<\/code>. Nous verrons plus bas l&rsquo;effet d&rsquo;ajouter une valeur enti\u00e8re \u00e0 un pointeur.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-c-dec-x3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte C.dec.x3<\/h5>\n<p>Donnez les lignes de code permettant de r\u00e9aliser la situation suivante en m\u00e9moire.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/3.png\" alt=\"image-20211220193939136\" \/><\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int z = 7;\nint* q = &amp;z;\nint** p = &amp;q;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p>R\u00e9alisez une fonction f qui ne retourne rien, accepte un param\u00e8tre <code>p<\/code> de type <code>int*<\/code> et a pour effet de mettre \u00e0 0 la variable point\u00e9e par <code>p<\/code>.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void f(int* p)\n{\n  *p =\u00a00;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"bonus\" class=\"anchor\" aria-hidden=\"true\"><\/a>Bonus<\/h4>\n<table>\n<thead>\n<tr>\n<th>Pointeurs sur rien et n&rsquo;importe quoi, affichage d&rsquo;un pointeur<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h5><a id=\"pointeur-sur-rien\" class=\"anchor\" aria-hidden=\"true\"><\/a>Pointeur sur rien<\/h5>\n<p>La valeur <code>NULL<\/code> peut \u00eatre plac\u00e9e dans toute variable de type pointeur. Elle ne correspond pas \u00e0 une adresse valide mais peut servir, par exemple, \u00e0 indiquer qu&rsquo;une variable de type pointeur n&rsquo;a pas encore \u00e9t\u00e9 assign\u00e9e avec une adresse.<\/p>\n<h5><a id=\"pointeur-sur-n-importe-quoi\" class=\"anchor\" aria-hidden=\"true\"><\/a>Pointeur sur n&rsquo;importe quoi<\/h5>\n<p>Les pointeurs que nous avons vu sont <strong>typ\u00e9s<\/strong>. Il pointent sur une donn\u00e9e d&rsquo;un type particulier, comme par exemple <code>int<\/code>, et le compilateur utilise cette information pour d\u00e9tecter certaines erreurs. Mais il existe des pointeurs de type <code>void*<\/code> qui peuvent pointer sur n&rsquo;importe quel type de donn\u00e9es. Vous ne devez pas les utiliser avant d&rsquo;avoir abord\u00e9 la gestion dynamique de la m\u00e9moire.<\/p>\n<h5><a id=\"afficher-un-pointeur\" class=\"anchor\" aria-hidden=\"true\"><\/a>Afficher un pointeur<\/h5>\n<p>Le format d&rsquo;affichage <code>%p<\/code> permet \u00e0 la fonction <code>printf<\/code> d&rsquo;afficher un pointeur sous le forme d&rsquo;une valeur hexad\u00e9cimale. L&rsquo;adresse des variables change \u00e0 chaque ex\u00e9cution d&rsquo;un programme, ce qui limite l&rsquo;int\u00e9r\u00eat d&rsquo;un tel affichage \u00e0 des utilisations exp\u00e9rimentales ou p\u00e9dagogiques.<\/p>\n<h3><a id=\"c-dec2-tableaux-statiques-et-automatiques\" class=\"anchor\" aria-hidden=\"true\"><\/a>C.dec2 : Tableaux statiques et automatiques<\/h3>\n<h4><a id=\"pr%C3%A9requis\" class=\"anchor\" aria-hidden=\"true\"><\/a>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Partie A et bonne compr\u00e9hension de ce qu&rsquo;est un pointeur.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4><a id=\"objectif\" class=\"anchor\" aria-hidden=\"true\"><\/a>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Stocker et repr\u00e9senter en m\u00e9moire une collection de donn\u00e9es de m\u00eame type.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Utiliser un tableau<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Les tableaux sont support\u00e9s par presque tous les langages de programmation. Ils permettent d&rsquo;organiser des donn\u00e9es de m\u00eame type et d&rsquo;acc\u00e9der \u00e0 chacune de ces donn\u00e9es \u00e0 l&rsquo;aide d&rsquo;un indice qui est un nombre entier.<\/p>\n<p>Voici un premier exemple de d\u00e9claration d&rsquo;un tableau en langage C. Pour changer un peu des entiers, nous allons cr\u00e9er un tableau de valeurs de type <code>double<\/code>, c&rsquo;est \u00e0 dire de nombres repr\u00e9sent\u00e9s en virgule flottante.<\/p>\n<pre><code class=\"language-c\">double tab[5];\n<\/code><\/pre>\n<p>On donne d&rsquo;abord le type de contenu de chaque cellule du tableau, puis le nom du tableau, puis, entre crochets, la taille du tableau, c&rsquo;est \u00e0 dire son nombre de cellules.<\/p>\n<p>Si la d\u00e9claration est situ\u00e9e dans le corps d&rsquo;une fonction, alors le tableau est <strong>local<\/strong> \u00e0 cette fonction et sa dur\u00e9e de vie sera la dur\u00e9e de l&rsquo;ex\u00e9cution de la fonction. Ces tableaux locaux de ce genre, aussi appel\u00e9s tableaux automatiques, ne peuvent pas \u00eatre tr\u00e8s grands car il sont stock\u00e9s dans la pile d&rsquo;ex\u00e9cution qui est un espace m\u00e9moire limit\u00e9. Leur taille ne devrait pas exc\u00e9der quelques milliers d&rsquo;octets.<\/p>\n<p>Si la d\u00e9claration n&rsquo;est pas dans le corps d&rsquo;une fonction, le tableau est <strong>global<\/strong>. Sa dur\u00e9e de vie est la dur\u00e9e d&rsquo;ex\u00e9cution du programme et il est accessible depuis n&rsquo;importe quelle fonction du fichier source o\u00f9 il est d\u00e9clar\u00e9, et m\u00eame au del\u00e0 dans le cas d&rsquo;un programme constitu\u00e9 de plusieurs fichiers sources, sous certaines conditions.<\/p>\n<p>Un tableau local (automatique) ou global a une taille fixe, d\u00e9termin\u00e9e lors de sa cr\u00e9ation et qui ne peut changer pendant toute sa dur\u00e9e d&rsquo;existence.<\/p>\n<p>Chaque cellule d&rsquo;un tableau s&rsquo;utilise comme une variable. Dans notre exemple, les cellules sont d\u00e9sign\u00e9es par les notations <code>tab[0]<\/code> \u00e0 <code>tab[4]<\/code>. La premi\u00e8re cellule a toujours l&rsquo;indice 0.<\/p>\n<p>On peut initialiser un tableau lors de sa d\u00e9claration. Voici quelques exemples.<\/p>\n<pre><code class=\"language-c\">double tab1[10] = {1.1, 2.5, 3.0};\n\/\/ Initialise le tableau avec les valeurs\n\/\/ 1.1, 2.5, 3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0\n\nint tab2[] = {2, 3, 5, 7};\n\/\/ Cr\u00e9e un tableau de taille 4 initialis\u00e9\n\/\/ avec 2, 3, 5, 7\n\ndouble tab3[10] = {0.0};\n\/\/ Toutes les cellules sont initialis\u00e9es avec 0.0\n<\/code><\/pre>\n<p>Cette syntaxe n&rsquo;est utilisable que lors de la d\u00e9claration du tableau. Ensuite, le seule mani\u00e8re de mettre des valeurs dans le tableau est de le faire cellule par cellule.<\/p>\n<p>Le langage C ne stocke pas en m\u00e9moire la longueur d&rsquo;un tableau, mais uniquement son contenu. Il ne v\u00e9rifie pas les d\u00e9bordements en cours d&rsquo;ex\u00e9cution. Voici un exemple.<\/p>\n<pre><code class=\"language-c\">void danger()\n{\n  double tab[5] = {0,0};\n  tab[7] = 1.0;            \/\/ ERREUR 1\n  tab[-1] = 2.0;           \/\/ ERREUR 2\n  for(int i=0; i&lt;=5; i++)  \/\/ ERREUR 3\n  {\n    printf(\"%d \", tab[i]);\n  }\n  printf(\"\\n\");\n}\n<\/code><\/pre>\n<p>Voyez vous les 3 erreurs dans cette fonction ?<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>les cellules <code>tab[-1]<\/code> et <code>tab[7]<\/code> n&rsquo;existent pas. La derni\u00e8re it\u00e9ration de la boucle affiche <code>tab[5]<\/code>, qui n&rsquo;existe pas non plus puisque le tableau a 5 cellules d&rsquo;indices 0 \u00e0 4.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p>Pourtant, lorsque j&rsquo;ai compil\u00e9 et ex\u00e9cut\u00e9 ce programme sur ma machine, il n&rsquo;y a eu aucune erreur et l&rsquo;affichage suivant a \u00e9t\u00e9 produit.<\/p>\n<pre><code class=\"language-plain_text\">0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 \n<\/code><\/pre>\n<p>Le programme a \u00e9crit la valeur 0.0 en m\u00e9moire \u00e0 des adresses situ\u00e9es en dehors des limites du tableau et a \u00e9galement affich\u00e9 une valeur situ\u00e9e en dehors de ces limites, qui c&rsquo;est trouv\u00e9e par hasard \u00e9gale \u00e0 0.0. Mais le comportement d&rsquo;un tel programme est impr\u00e9visible. Il peut avoir pour effet d&rsquo;\u00e9craser les contenus d&rsquo;autres variables et de provoquer des erreurs graves. <strong>C&rsquo;est au programmeur de faire en sorte de ne jamais lire ni \u00e9crire dans une cellule situ\u00e9e en dehors d&rsquo;un tableau<\/strong>.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-c-dec-x4\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte C.dec.x4<\/h5>\n<p>Donnez les lignes de code permettant de cr\u00e9er un tableau d&rsquo;entiers non sign\u00e9s de taille 10, et de remplir ce tableau avec des nombres al\u00e9atoires compris entre 1 et 10.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">unsigned tab[10];\nfor(int i=0; i &lt; 10; i++)\n{\n  tab[i] = 1 + rand()%10;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-c-dec-x5\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte C.dec.x5<\/h5>\n<p>En ex\u00e9cutant les lignes de codes suivantes, situ\u00e9es dans la m\u00e9thode <code>main<\/code>&#8230;<\/p>\n<pre><code class=\"language-c\">int tab[10];\nfor(int i=0; i &lt; 10; i++)\n{\n    printf(\"%d \", tab[i]);\n}\nprintf(\"\\n\");\n<\/code><\/pre>\n<p>&#8230;j&rsquo;ai obtenu l&rsquo;affichage suivant :<\/p>\n<pre><code class=\"language-plain_text\">1422503880 32609 608723920 22008 0 0 608723136 22008 1130632544 32764\n<\/code><\/pre>\n<p>Tentez d&rsquo;expliquer ce r\u00e9sultat.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Le tableau n&rsquo;a pas \u00e9t\u00e9 initialis\u00e9. Les valeurs affich\u00e9es correspondent au contenu de la m\u00e9moire occup\u00e9e par le tableau. Elles sont impr\u00e9visibles.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"c-dec3-passage-de-tableaux-en-param%C3%A8tres\" class=\"anchor\" aria-hidden=\"true\"><\/a>C.dec3 : Passage de tableaux en param\u00e8tres<\/h3>\n<h4><a id=\"pr%C3%A9requis\" class=\"anchor\" aria-hidden=\"true\"><\/a>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Ma\u00eetriser les pointeurs et les tableaux.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4><a id=\"objectif\" class=\"anchor\" aria-hidden=\"true\"><\/a>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>R\u00e9aliser une fonction capable de lire et modifier un ou plusieurs tableaux pass\u00e9s en param\u00e8tres.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Par exemple, il est pratique de disposer d&rsquo;une fonction permettant d&rsquo;afficher tout ou partie des valeurs contenues dans un tableau d&rsquo;entiers, ou encore d&rsquo;une fonction r\u00e9initialisant \u00e0 0 tout ou partie des cellules d&rsquo;un tableau d&rsquo;entiers. Ces fonctions doivent pouvoir \u00eatre appel\u00e9es avec n&rsquo;importe quel tableau d&rsquo;entiers, ce qui suppose d&rsquo;indiquer, lors de l&rsquo;appel de la fonction, le tableau \u00e0 afficher ou \u00e0 modifier.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Correspondance entre tableau et pointeur, passage d&rsquo;un tableau en param\u00e8tre.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>En langage C, il y a une relation tr\u00e8s \u00e9troite entre tableaux et pointeurs. Cette relation est souvent appel\u00e9e \u00ab\u00a0\u00e9quivalence entre tableaux et pointeurs\u00a0\u00bb, mais le terme est un peu trompeur et je pr\u00e9f\u00e8re parler de correspondance entre tableaux est pointeurs. Cette notion se r\u00e9sume ainsi :<\/p>\n<ul>\n<li><strong>Tout nom de tableau est consid\u00e9r\u00e9<\/strong> par le compilateur C comme \u00e9tant un <strong>pointeur<\/strong> sur la premi\u00e8re cellule du tableau concern\u00e9.<\/li>\n<li><strong>Tout pointeur peut \u00eatre utilis\u00e9 comme un nom de tableau<\/strong>. Mais en pratique une telle utilisation ne doit \u00eatre faite que si le pointeur pointe effectivement une cellule de tableau. Dans le cas contraire, les cons\u00e9quences sont impr\u00e9visibles et dangereuses : corruption de m\u00e9moire, \u00e9crasement de variables, plantage, etc.<\/li>\n<\/ul>\n<p>Illustrons ce principe avec un exemple.<\/p>\n<pre><code class=\"language-c\">double tab[5] = {0.0};\ndouble* p = tab;             \/\/ Ligne A\np[2] = 3.35;                 \/\/ Ligne B\nfor(int i=0; i &lt; 5; i++)\n{\n  printf(\"%.02f \", tab[i]);  \/\/ Ligne C\n}\nprintf(\"\\n\");\n<\/code><\/pre>\n<p>L&rsquo;ex\u00e9cution de ces lignes de code (qui doivent \u00e9videmment se trouver dans une fonction, par exemple dans <code>main<\/code>), produit l&rsquo;affichage suivant :<\/p>\n<pre><code class=\"language-plain_text\">0.00 0.00 3.35 0.00 0.00 \n<\/code><\/pre>\n<p><strong>En ligne A<\/strong> la variable <code>p<\/code>, de type pointeur sur <code>double<\/code>, est initialis\u00e9e avec l&rsquo;adresse du tableau <code>tab<\/code>.<\/p>\n<p><strong>En ligne B<\/strong> la variable <code>p<\/code> est utilis\u00e9e pour acc\u00e9der \u00e0 la troisi\u00e8me cellule du tableau <code>tab<\/code>.<\/p>\n<p>Tout ceci est rendu possible par la correspondance entre tableaux et pointeurs.<\/p>\n<p><strong>En ligne C<\/strong>, on affiche une cellule du tableau <code>tab<\/code>. \u00c0 la place de <code>tab[i]<\/code>, on aurait pu \u00e9crire <code>p[i]<\/code>.<\/p>\n<p>\u00c0 pr\u00e9sent, corsons un peu les choses.<\/p>\n<pre><code class=\"language-c\">double tab[5] = {0.0};\ndouble* p = tab + 2;             \/\/ Ligne A\np[1] = 3.35;                     \/\/ Ligne B\np[-1] = 2.56;                    \/\/ Ligne C\nfor(int i=0; i &lt; 5; i++)\n{\n  printf(\"%.02f \", tab[i]);\n}\nprintf(\"\\n\");\n<\/code><\/pre>\n<p>L&rsquo;affichage produit est :<\/p>\n<pre><code class=\"language-plain_text\">0.00 2.56 0.00 3.35 0.00 \n<\/code><\/pre>\n<p>Ce que nous voyons l\u00e0 est \u00e0 la fois puissant et dangereux, comme beaucoup de possibilit\u00e9s du langage C.<\/p>\n<p><strong>En ligne A<\/strong> apparait une nouveaut\u00e9 qui rel\u00e8ve de ce qu&rsquo;on appelle <strong>l&rsquo;arithm\u00e9tique des pointeurs<\/strong>. On peut ajouter ou soustraire un entier \u00e0 un pointeur et le r\u00e9sultat est un pointeur. Si <code>p<\/code> est un pointeur sur un type <code>T<\/code>, et <code>x<\/code> un entier, alors <code>p + x<\/code> d\u00e9signe l&rsquo;adresse obtenue en ajoutant \u00e0 <code>x<\/code> fois <code>sizeof(T)<\/code> \u00e0 <code>p<\/code>. (Et <code>p - x<\/code> fonctionne de mani\u00e8re similaire.) Ce type de calcul n&rsquo;a d&rsquo;int\u00e9r\u00eat que si <code>p<\/code> d\u00e9signe une cellule de tableau. Dans ce cas, <code>p + x<\/code> d\u00e9signe la cellule suit\u00e9e <code>x<\/code> positions apr\u00e8s celle point\u00e9e par <code>p<\/code> (et <code>p - x<\/code>, <code>x<\/code> positions avant).<\/p>\n<p><strong>En ligne B<\/strong>, on modifie la cellule <code>p[1]<\/code>, c&rsquo;est \u00e0 dire la cellule situ\u00e9e une position apr\u00e8s la cellule d\u00e9sign\u00e9e par <code>p<\/code>, qui lui m\u00eame pointe la cellule <code>tab[2]<\/code>. La cellule <code>p[1]<\/code> est donc la cellule <code>tab[3]<\/code>.<\/p>\n<p><strong>En ligne C<\/strong>, on modifie la cellule <code>p[-1]<\/code> qui est aussi la cellule <code>tab[1]<\/code>.<\/p>\n<p>Illustrons ceci avec un dessin.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/4.png\" alt=\"image-20211221165808948\" \/><\/p>\n<p>Il y a une subtilit\u00e9 \u00e0 saisir. <code>p<\/code> d\u00e9signe une <strong>variable<\/strong> de type <code>double*<\/code>, alors que <code>tab<\/code>, le nom du tableau, est une <strong>constante<\/strong> de type <code>double*<\/code>. On peut modifier <code>p<\/code>, mais on ne peut changer la valeur de <code>tab<\/code> car la localisation du tableau en m\u00e9moire est d\u00e9termin\u00e9e lors de sa d\u00e9claration et ne peut \u00eatre modifi\u00e9e.<\/p>\n<p>La correspondance entre tableaux et pointeurs est sp\u00e9cialement utile pour r\u00e9aliser des fonctions acceptant des tableaux en param\u00e8tres. En effet, le langage C ne permet pas de passer un tableau en argument en copie, mais on peut utiliser <strong>des param\u00e8tres de types pointeurs<\/strong> pour permettre \u00e0 une fonction d&rsquo;acc\u00e9der \u00e0 un tableau existant.<\/p>\n<p>Voici le premier exemple qui correspond \u00e0 un de nos objectifs : <strong>r\u00e9aliser une fonction qui affiche tout ou partie d&rsquo;un tableau d&rsquo;entiers<\/strong>.<\/p>\n<pre><code class=\"language-c\">\/\/ Affiche les n premiers \u00e9l\u00e9ments du tableau d\u00e9sign\u00e9 par tab\nvoid printTabInt(int* tab, int n)\n{\n  for(int i=0; i&lt;n; i++)\n  {\n    printf(\"%d \",tab[i]);\n  }\n  printf(\"\\n\");\n}\n<\/code><\/pre>\n<p>Cette fonction peut afficher n&rsquo;importe quel tableau d&rsquo;entiers d\u00e9sign\u00e9 par le param\u00e8tre <code>tab<\/code>. Le modificateur <code>const<\/code> indique que la fonction ne modifie pas le tableau. La valeur de <code>n<\/code> ne doit en aucun cas exc\u00e9der la taille du tableau \u00e0 afficher, et il est impossible de le v\u00e9rifier dans la fonction car un pointeur sur un tableau ne permet pas de r\u00e9cup\u00e9rer la taille de ce tableau. R\u00e9aliser une fonction \u00e0 un seul param\u00e8tre qui affiche la taille d&rsquo;un tableau d&rsquo;entiers quelconque est juste impossible. Voici un exemple d&rsquo;utilisation.<\/p>\n<pre><code class=\"language-c\">int main()\n{\n    int t[8] = {2,3,5,7,11};\n    printTabInt(t,8);\n    return 0;\n}\n<\/code><\/pre>\n<p>Le r\u00e9sultat de l&rsquo;ex\u00e9cution est :<\/p>\n<pre><code class=\"language-c\">2 3 5 7 11 0 0 0 \n<\/code><\/pre>\n<h5><a id=\"exercice-de-d%C3%A9couverte-c-dec-x6\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte C.dec.x6<\/h5>\n<p>Que se passerait-il si on ex\u00e9cutait les lignes de code suivantes ? Tentez de r\u00e9pondre sans utiliser de machine.<\/p>\n<pre><code class=\"language-c\">    int t[8] = {2,3,5,7,11};\n    printTabInt(t,10);\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Le r\u00e9sultat est impr\u00e9visible car des emplacements m\u00e9moire situ\u00e9s au del\u00e0 des limites du tableau vont \u00eatre lus, interpr\u00e9t\u00e9s comme des entiers, et affich\u00e9s.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p>Soit le programme suivant.<\/p>\n<pre><code class=\"language-c\">void unEssai(int* tab)\n{\n  printf(\"%ld\\n\", sizeof(tab));\n}\n\nint main()\n{\n    int t[100] = {0};\n    printf(\"%ld\\n\", sizeof(t));\n    unEssai(t);\n    return 0;\n}\n<\/code><\/pre>\n<p>\u00c0 l&rsquo;ex\u00e9cution, les valeurs 400 et 8 sont affich\u00e9es. Pourquoi ? Quelle est l&rsquo;information donn\u00e9e par chacune de ces valeurs ?<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p><code>sizeof(t)<\/code> donne la taille en octets de la repr\u00e9sentation en m\u00e9moire du tableau <code>t<\/code>.<\/p>\n<p><code>sizeof(tab)<\/code> donne la taille de le repr\u00e9sentation en m\u00e9moire du <strong>pointeur<\/strong> <code>tab<\/code>, mais pas celle du tableau point\u00e9. On en d\u00e9duit que sur la machine ayant \u00e9t\u00e9 utilis\u00e9e pour l&rsquo;exp\u00e9rience, les pointeurs ont une taille en m\u00e9moire de 8 octets (64 bits).<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-c-dec-x7\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte C.dec.x7<\/h5>\n<p>Notre deuxi\u00e8me objectif \u00e9tait de r\u00e9aliser une fonction r\u00e9initialisant \u00e0 0 tout ou partie des cellules d&rsquo;un tableau d&rsquo;entiers. Voici le squelette d&rsquo;une telle fonction. Tentez de le compl\u00e9ter \u00e0 titre d&rsquo;exercice.<\/p>\n<pre><code class=\"language-c\">\/\/ Met \u00e0 0 les n premi\u00e8res cellules du tableau tab\nvoid raz(int* tab, int n)\n{\n  \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void raz(int* tab, int n)\n{\n  for(int i=0; i&lt;n; i++)\n  {\n    tab[i] = 0;\n  }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"bonus\" class=\"anchor\" aria-hidden=\"true\"><\/a>Bonus<\/h4>\n<table>\n<thead>\n<tr>\n<th>\u00c9quivalences de certaines notations. Soustraction de pointeurs.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>La fonction <code>raz<\/code> peut \u00eatre \u00e9crite avec une autre notation du type du param\u00e8tre d\u00e9signant un tableau d&rsquo;entier :<\/p>\n<pre><code class=\"language-c\">void raz(int tab[], int n)\n{\n  for(int i=0; i&lt;n; i++)\n  {\n    tab[i] = 0;\n  }\n}\n<\/code><\/pre>\n<p>C&rsquo;est une diff\u00e9rence purement cosm\u00e9tique, plus lisible dans la mesure o\u00f9 il est explicite que le premier param\u00e8tre d\u00e9signe un tableau d&rsquo;entiers. Mais ce param\u00e8tre est en fait toujours un pointeur sur <code>int<\/code> et l&rsquo;utilisation ne change pas.<\/p>\n<hr \/>\n<p>La correspondance entre pointeur et tableau induit l&rsquo;\u00e9quivalence des notations suivantes. Soit <code>tab<\/code> un tableau ou une variable de type pointeur d\u00e9signant un tableau. Soit <code>i<\/code> un entier ou une variable contenant un entier positif ou nul inf\u00e9rieur \u00e0 la taille du tableau.<\/p>\n<ul>\n<li><code>tab<\/code> est \u00e9quivalent \u00e0 <code>&amp;(tab[0])<\/code>.<\/li>\n<li><code>tab[i]<\/code> est \u00e9quivalent \u00e0 <code>*(tab + i)<\/code>.<\/li>\n<li><code>&amp;(tab[i])<\/code> est \u00e9quivalent \u00e0 <code>tab + i<\/code>.<\/li>\n<\/ul>\n<hr \/>\n<p>Il est possible de soustraire deux pointeurs, bien que cela n&rsquo;ait un int\u00e9r\u00eat que si les deux pointeurs concern\u00e9s d\u00e9signent des cellules d&rsquo;un m\u00eame tableau. La diff\u00e9rence de deux pointeurs est de type <code>size_t<\/code>, \u00e9quivalent \u00e0 <code>unsigned long<\/code>.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-c-dec-x8\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte C.dec.x8<\/h5>\n<p>Donnez l&rsquo;affichage produit par l&rsquo;ex\u00e9cution des lignes suivantes.<\/p>\n<pre><code class=\"language-c\">int t[100] = {0};\nint* p1 = t + 10;\nint* p2 = t + 12;\nprintf(\"%ld\\n\", p2-p1);\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>La valeur 2 est affich\u00e9e car <code>p2-p1<\/code> repr\u00e9sente le nombre de donn\u00e9es situ\u00e9es entre l&#8217;emplacement d\u00e9sign\u00e9 par <code>p1<\/code> et celui d\u00e9sign\u00e9 par <code>p2<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>L&rsquo;activit\u00e9 est termin\u00e9e. Vous devez \u00e9valuer votre r\u00e9ussite de cette activit\u00e9 par une valeur entre 1 et 4.<\/p>\n<ol>\n<li>Vous n&rsquo;avez presque rien compris et \u00e9chou\u00e9 \u00e0 plus de la moiti\u00e9 des exercices de d\u00e9couverte.<\/li>\n<li>Vous estimez avoir compris une partie des explications et vous avez r\u00e9ussi au moins la moiti\u00e9 des exercices de d\u00e9couverte, mais certaines notions sont encore floues.<\/li>\n<li>Vous estimez avoir bien compris les explications et vous avez r\u00e9ussi presque tous les exercices de d\u00e9couverte, mais certaines notions abord\u00e9es \u00e9taient nouvelles et vous penser avoir besoin d&rsquo;un entrainement pour bien les assimiler et \u00eatre en mesure de les utiliser en pratique.<\/li>\n<li>Vous connaissiez d\u00e9j\u00e0 tout ce qui a \u00e9t\u00e9 pr\u00e9sent\u00e9 (sauf peut \u00eatre quelques d\u00e9tails) et il ne sera pas n\u00e9cessaire que vous reveniez sur ces notions.<\/li>\n<\/ol>\n<p>Si votre score est 1 ou 2, vous devrez refaire cette activit\u00e9 rapidement, <strong>mais apr\u00e8s au moins une nuit de sommeil<\/strong>, avant de passer aux activit\u00e9s suivantes. Si votre score est 3 ou 4, vous devez faire les activit\u00e9s suivantes et il ne sera pas n\u00e9cessaire de revenir sur cette activit\u00e9, \u00e0 part pour rechercher des informations utiles pour d&rsquo;autres activit\u00e9s.<\/p>\n<hr \/>\n<h2><a id=\"activit%C3%A9-d-entra%C3%AEnement-c-ent\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 d&rsquo;entra\u00eenement C.ent<\/h2>\n<p>Cette activit\u00e9 est essentielle. C&rsquo;est gr\u00e2ce \u00e0 elle que vous apprendrez vraiment \u00e0 comprendre et utiliser les notions vues pr\u00e9c\u00e9demment. Elle se d\u00e9compose en plusieurs <strong>it\u00e9rations<\/strong> : <strong>ent1<\/strong>, <strong>ent2<\/strong>, etc.<\/p>\n<p>Vous devez r\u00e9aliser au moins une it\u00e9ration et \u00e9valuer votre niveau de r\u00e9ussite par une valeur entre 1 et 4 selon les crit\u00e8res habituels. L&rsquo;it\u00e9ration que vous avez trait\u00e9 le plus r\u00e9cemment est appel\u00e9e <strong>it\u00e9ration courante<\/strong>. On appelle <strong>it\u00e9ration suivante<\/strong> celle qui suit l&rsquo;it\u00e9ration courante, except\u00e9 si l&rsquo;it\u00e9ration courante est la derni\u00e8re disponible, auquel cas l&rsquo;it\u00e9ration suivante est la premi\u00e8re it\u00e9ration.<\/p>\n<p><strong>Si le r\u00e9sultat est 1<\/strong>, vous devrez traiter \u00e0 nouveau l&rsquo;activit\u00e9 de d\u00e9couverte pr\u00e9c\u00e9dente, en laissant passer au moins une nuit, avant de revenir \u00e0 cette activit\u00e9 d&rsquo;entra\u00eenement en r\u00e9alisant \u00e0 nouveau l&rsquo;it\u00e9ration courante. Vous devez aussi essayer d&rsquo;identifier les points de blocage et demander \u00e0 votre enseignant de vous aider \u00e0 les surmonter.<\/p>\n<p><strong>Si le r\u00e9sultat est 2<\/strong>, vous devrez d&rsquo;abord comprendre ce qui vous a conduit \u00e0 des erreurs et \/ ou ce qui vous a bloqu\u00e9. Si vous avez des doutes, des difficult\u00e9s, essayez de trouver les r\u00e9ponses dans les pr\u00e9sentations et explication de l&rsquo;activit\u00e9 de d\u00e9couverte pr\u00e9c\u00e9dente et demandez toute l&rsquo;aide n\u00e9cessaire \u00e0 votre enseignant. Ensuite, vous devrez r\u00e9aliser l&rsquo;it\u00e9ration suivante de l&rsquo;activit\u00e9 d&rsquo;entra\u00eenement actuelle apr\u00e8s un d\u00e9lai d&rsquo;au moins deux jours et d&rsquo;au plus une semaine.<\/p>\n<p><strong>Si le r\u00e9sultat est 3<\/strong>, vous devrez revenir traiter l&rsquo;it\u00e9ration suivante apr\u00e8s un d\u00e9lai de plusieurs semaines.<\/p>\n<p>En traitant les exercices, vous devrez consid\u00e9rer que les param\u00e8tres des fonctions ont des valeurs correctes. Il ne vous est pas demand\u00e9 de v\u00e9rifier si certaines valeurs sont aberrantes au regard de ce que demande l&rsquo;\u00e9nonc\u00e9. Par exemple, si un param\u00e8tre doit \u00eatre positif pour que le traitement demand\u00e9 soit possible, vous consid\u00e9rerez que la fonction sera appel\u00e9e avec une valeur positive de ce param\u00e8tre.<\/p>\n<p><strong>Vous pouvez utiliser un ordinateur<\/strong> pour tester vos solutions et les corriger en cas de comportement inattendu. C&rsquo;est m\u00eame <strong>recommand\u00e9<\/strong>, <strong>\u00e0 condition de commencer par r\u00e9fl\u00e9chir avant de vous jeter sur le clavier<\/strong>. Si vous pensez avoir une solution diff\u00e9rente de celle propos\u00e9e, ce qui peut arriver souvent, vous ne devez en aucun cas rester dans le doute. Vous <strong>devez<\/strong> v\u00e9rifier si votre solution est correcte ou non, soit en testant votre solution avec un ordinateur, soit en demandant \u00e0 une personne enseignante.<\/p>\n<h3><a id=\"it%C3%A9ration-c-ent1\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration C.ent1<\/h3>\n<h4><a id=\"exercice-d-entrainement-c-ent1-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement C.ent1.1<\/h4>\n<p>Vous devez r\u00e9aliser une fonction <code>fillRand<\/code> qui ne retourne rien et qui accepte un param\u00e8tre <code>tab<\/code> d\u00e9signant un tableau d\u2019entiers, un param\u00e8tre <code>n<\/code> de type <code>int<\/code>, et un param\u00e8tre <code>k<\/code> de type <code>int<\/code>. Cette fonction doit avoir pour effet de remplir les <code>n<\/code> premi\u00e8res cellules du tableau d\u00e9sign\u00e9 par <code>tab<\/code> avec des valeurs pseudoal\u00e9atoires comprisent entre 0 (inclus) et <code>k-1<\/code> (inclus).<br \/>\nDonnez les lignes de code permettant de cr\u00e9er un tableau de 10 cellules de type <code>int<\/code> et qui appelle la fonction <code>fillRand<\/code> pour remplir ce tableau avec des entiers pseudoal\u00e9atoires compris entre 0 et 10.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void fillRand(int tab[], int n, int k)\n{\n  \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\n<p>Il reste \u00e0 parcourir le tableau et \u00e0 placer un nombre al\u00e9atoire, obtenu par <code>rand()%k<\/code>, dans chaque cellule.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void fillRand(int tab[], int n, int k)\n{\n  for(int i=0; i&lt;n; i++)\n  {\n    tab[i] = rand()%k;\n  }\n}\n<\/code><\/pre>\n<pre><code class=\"language-c\">void main()\n{\n  int t[10];\n  fillRand(t,10,10);\n  printTabInt(t,10); \/\/ Pour v\u00e9rification\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-c-ent1-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement C.ent1.2<\/h4>\n<p>R\u00e9alisez une fonction nomm\u00e9e <code>rotG<\/code> qui accepte un param\u00e8tre <code>tab<\/code> d\u00e9signant un tableau d\u2019entiers et un param\u00e8tre <code>n<\/code> de type <code>int<\/code>. En supposant que <code>n<\/code> soit la taille du tableau, cette fonction doit r\u00e9aliser une rotation \u00e0 gauche de toutes les valeurs du tableau. La premi\u00e8re valeur doit se retrouver \u00e0 la fin et chacune des autres d\u00e9cal\u00e9es d\u2019une position vers la gauche.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/5.png\" alt=\"image-20211221203751068\" \/><\/p>\n<p>Donnez les lignes de code permettant de d\u00e9clarer un tableau de 7 entiers, initialis\u00e9 avec les valeurs 1, 2, 3, 4, 5, 6, 7, puis de r\u00e9aliser une rotation \u00e0 gauche des 5 valeurs centrales par un appel \u00e0 la fonction <code>rotG<\/code>. \u00c0 l&rsquo;issue de l&rsquo;ex\u00e9cution de ces lignes, le tableau devra contenir les valeurs 1, 3, 4, 5, 6, 2, 7.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>On s&rsquo;int\u00e9resse d&rsquo;abord \u00e0 la fonction <code>rotG<\/code>. Pour \u00e9viter d&rsquo;\u00e9craser une valeur, il faut utiliser une variable dans laquelle on place la premi\u00e8re valeur du tableau. On peut ensuite, gr\u00e2ce \u00e0 une boucle, d\u00e9placer une \u00e0 une les autres valeurs. Attention au nombre d&rsquo;it\u00e9rations de la boucle et aux valeurs initiale et finale de la variable qui contr\u00f4le cette boucle. \u00c0 l&rsquo;issue de l&rsquo;ex\u00e9cution de la boucle, la valeur sauvegard\u00e9e doit \u00eatre plac\u00e9e dans le derni\u00e8re cellule du tableau.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice2<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Voici le d\u00e9tail de la fonction <code>rotG<\/code>.<\/p>\n<pre><code class=\"language-c\">void rotG(int tab[], int n)\n{\n    int valGauche = tab[0];\n    for(int i=0; i&lt;n-1; i++)\n    {\n        tab[i] = tab[i+1];\n    }\n    tab[n-1] = valGauche;\n}\n<\/code><\/pre>\n<p>Il reste \u00e0 \u00e9crire le code permettant de r\u00e9aliser une rotation des cellules d&rsquo;indice 1 \u00e0 5 du tableau suivant.<\/p>\n<pre><code class=\"language-c\">int t[] = {1,2,3,4,5,6,7};\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>La fonction <code>rotG<\/code> est d\u00e9finie dans l&rsquo;indice pr\u00e9c\u00e9dent. Le code demand\u00e9 est le suivant.<\/p>\n<pre><code class=\"language-c\">  int t[] = {1,2,3,4,5,6,7};\n  rotG(t+1,5);\n  printTabInt(t,7); \/\/ Pour v\u00e9rification\n<\/code><\/pre>\n<p>La fonction d&rsquo;affichage <code>printTabInt<\/code> est celle donn\u00e9e dans l&rsquo;activit\u00e9 de d\u00e9couverte. Elle permet, si vous travaillez sur machine, de tester la solution propos\u00e9e.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-c-ent1-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement C.ent1.3<\/h4>\n<p>Que fait la fonction suivante ?<\/p>\n<pre><code class=\"language-c\">void exg(int* p, int*q)\n{\n  int tmp = *p;\n  *p = *q;\n  *q = tmp;\n}\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Elle \u00e9change les valeurs situ\u00e9es aux emplacement m\u00e9moire point\u00e9s par <code>p<\/code> et <code>q<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p>Compl\u00e9tez la fonction suivante de mani\u00e8re \u00e0 ce qu&rsquo;elle ait pour effet de r\u00e9organiser les \u00e9l\u00e9ments situ\u00e9s dans les <code>n<\/code> premi\u00e8res cellules du tableau d\u00e9sign\u00e9 par <code>tab<\/code> en faisant en sorte que la plus petite valeur apparaisse en premi\u00e8re position. Toutes les autres valeurs peuvent changer de place, leurs positions ne sont pas critiques. Par contre aucune valeur ne doit \u00eatre perdue. \u00c0 l&rsquo;ordre des valeurs pr\u00e8s, le contenu du tableau ne doit pas changer.<\/p>\n<p>Si par exemple <code>n<\/code> 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\u00e9but mais toutes les autres valeurs peuvent changer de place, d\u00e8s lors qu&rsquo;elles restent dans le tableau. Vous devez utiliser la fonction <code>exg<\/code>.<\/p>\n<pre><code class=\"language-c\">void metMinAuDebut(int tab[], int n)\n{\n  for(int i=1; i&lt;n; i++)\n  {\n    if(t[0] &gt; t[i])\n    {\n      \/\/ \u00c0 compl\u00e9ter\n    }\n  }\n}\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>La ligne \u00e0 compl\u00e9ter est :<\/p>\n<pre><code class=\"language-c\">exg(tab, tab+i);\n<\/code><\/pre>\n<p>Mais elle pourrait aussi s&rsquo;\u00e9crire, de mani\u00e8re strictement \u00e9quivalente :<\/p>\n<pre><code class=\"language-c\">exg(&amp;(tab[0]), &amp;(tab[i]);\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p>Vous devez maintenant compl\u00e9ter la fonction suivante&#8230;<\/p>\n<pre><code class=\"language-c\">void triTabInt(int tab[], int n)\n{\n  \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\n<p>&#8230;de mani\u00e8re \u00e0 ce qu&rsquo;elle ait pour effet de trier en ordre croissant les <code>n<\/code> premi\u00e8res valeurs du tableau d\u00e9sign\u00e9 par <code>tab<\/code>. Vous devez utiliser une boucle dans le corps de laquelle il y a un appel \u00e0 la fonction <code>metMinAuDebut<\/code>. Le principe \u00e0 appliquer est le suivant :<\/p>\n<ul>\n<li>On imagine que le tableau est constitu\u00e9 de deux parties : une partie tri\u00e9e, initialement vide, et le reste du tableau qui ne contient aucune valeur plus petite que celles situ\u00e9es dans la partie tri\u00e9e.<\/li>\n<li>\u00c0 chaque it\u00e9ration, on ajoute une valeur \u00e0 la partie tri\u00e9e.<\/li>\n<\/ul>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/6.png\" alt=\"image-20211222113657265\" \/><\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void triTabInt(int tab[], int n)\n{\n  for(int i=0; i &lt; n-1; i++)\n  {\n      \/\/ \u00c0 compl\u00e9ter\n  }\n}\n<\/code><\/pre>\n<p>La partie \u00e0 compl\u00e9ter comporte juste un appel \u00e0 la fonction <code>metMinAuDebut<\/code>. La difficult\u00e9 est de trouver les valeurs \u00e0 passer en param\u00e8tres \u00e0 cette fonction. (C&rsquo;est \u00e0 dire, pour utiliser un langage plus rigoureux, les arguments de l&rsquo;appel de la fonction.)<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void triTabInt(int tab[], int n)\n{\n  for(int i=0; i &lt; n-1; i++)\n  {\n      metMinAuDebut(tab+i, n-i);\n  }\n}\n<\/code><\/pre>\n<p>Si celle solution n&rsquo;est pas claire pour vous, identifiez bien ce qui vous pose probl\u00e8me : l&rsquo;aspect algorithmique ou bien l&rsquo;argument <code>tab+i<\/code> ? Dans le premier cas, prenez le temps de simuler \u00e0 la main les premi\u00e8re \u00e9tapes. Dans le deuxi\u00e8me cas, r\u00e9\u00e9tudiez les parties pr\u00e9sentant les tableaux et la correspondance entre tableaux et pointeurs dans l&rsquo;activit\u00e9 de d\u00e9couverte pr\u00e9c\u00e9dente. Finalement, en langage C, un tableau n&rsquo;est rien d&rsquo;autre qu&rsquo;une suite de donn\u00e9es contig\u00fces en m\u00e9moire. La notation <code>int tab[]<\/code> ne d\u00e9signe rien d&rsquo;autre qu&rsquo;un param\u00e8tre de type pointeur qui n&rsquo;est pas oblig\u00e9 de pointer le d\u00e9but d&rsquo;un tableau, mais qui peut pointer plus loin dans le tableau. La partie non tri\u00e9e peut \u00eatre vue comme un tableau \u00e0 part enti\u00e8re.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"it%C3%A9ration-c-ent2\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration C.ent2<\/h3>\n<h4><a id=\"exercice-d-entrainement-c-ent2-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement C.ent2.1<\/h4>\n<p>R\u00e9alisez une fonction nomm\u00e9e <code>isIn<\/code> qui accepte un param\u00e8tre <code>tab<\/code> d\u00e9signant un tableau d\u2019entiers, un<br \/>\nparam\u00e8tre <code>n<\/code> de type <code>int<\/code>, et un troisi\u00e8me param\u00e8tre <code>val<\/code> de type <code>int<\/code>. En supposant que <code>n<\/code> soit au plus \u00e9gal \u00e0 la taille du tableau, cette fonction doit retourner un entier non nul (repr\u00e9sentant le Bool\u00e9en true) si <code>val<\/code> est dans les <code>n<\/code> premi\u00e8res cellules de <code>tab<\/code>, et doit retourner 0 (false) dans le cas contraire.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int isIn(int tab[], int n, int val)\n{\n  \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\n<p>Il reste \u00e0 parcourir le tableau et comparer la valeur de chaque cellule avec <code>val<\/code>. Si une cellule \u00e9gale \u00e0 <code>val<\/code> est trouv\u00e9e, on retourne directement la valeur 1. Si la boucle parcourt tout le tableau sans trouver <code>val<\/code>, la fonction retourne 0.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int isIn(int tab[], int n, int val)\n{\n  for(int i=0; i&lt;n; i++)\n  {\n    if(tab[i] == val) return 1;\n  }\n  return 0;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-c-ent2-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement C.ent2.2<\/h4>\n<p>R\u00e9alisez une fonction&#8230;<\/p>\n<pre><code class=\"language-c\">void minMaxTab(int tab[], int n, int* min, int* max)\n<\/code><\/pre>\n<p>&#8230;permettant de rechercher la plus petite et la plus grande valeur d&rsquo;un tableau. Le param\u00e8tre <code>tab<\/code> d\u00e9signe le tableau et <code>n<\/code> donne sa taille. Les param\u00e8tres <code>min<\/code> et <code>max<\/code> doivent pointer des variables, situ\u00e9es \u00e0 l&rsquo;ext\u00e9rieur de la fonction, dans lesquelles les r\u00e9sultats doivent \u00eatre plac\u00e9s. On suppose que le tableau comporte au moins une cellule. Voici un exemple de fonction <code>main<\/code> permettant de tester la fonction \u00e0 r\u00e9aliser. Vous devez compl\u00e9ter cette fonction <code>main<\/code> avant de continuer l&rsquo;exercice.<\/p>\n<pre><code class=\"language-c\">int main()\n{\n  int t[] = {2,5,3,7,1,8,2,3};\n  int mini; int maxi;\n  minMaxTab(\/* \u00c0 compl\u00e9ter *\/);  \/\/ ligne A\n  printf(\"minimum = %d, maximum = %d\\n\", mini, maxi);\n  return 0;\n}\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>La ligne A de la fonction <code>main<\/code> doit \u00eatre :<\/p>\n<pre><code class=\"language-c\">  minMaxTab(t, 8, &amp;mini, &amp;maxi);\n<\/code><\/pre>\n<p>Il faut passer en param\u00e8tres les adresses des variables <code>mini<\/code> et <code>maxi<\/code> dans lesquelles la fonction placera son r\u00e9sultat. Dans la fonction, les contenus de ces variables seront accessibles en utilisant les notations <code>*min<\/code> et <code>*max<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice2<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void minMaxTab(int tab[], int n, int* min, int* max)\n{\n    *min = tab[0];\n    *max = tab[0];\n    for(int i=1; i&lt;n; i++)\n    {\n        \/\/ \u00c0 compl\u00e9ter\n    }\n}\n<\/code><\/pre>\n<p>Il faut bien comprendre que <code>*min<\/code> et <code>*max<\/code> d\u00e9signent les variables, situ\u00e9es \u00e0 l&rsquo;ext\u00e9rieur de la fonction, dans lesquelles la plus petite et la plus grande valeur du tableau seront plac\u00e9es. Mais rien ne nous emp\u00eache d&rsquo;utiliser ces variables pour y placer des r\u00e9sultats interm\u00e9diaires. On commence par y mettre la premi\u00e8re valeur du tableau. Il reste \u00e0 parcourir les cellules restantes et \u00e0 mettre \u00e0 jour <code>*min<\/code> et <code>*max<\/code> \u00e0 chaque fois qu&rsquo;une valeur plus petite que <code>*min<\/code> ou qu&rsquo;une valeur plus grande que <code>*max<\/code> est trouv\u00e9e.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Voici une version compl\u00e8te de la fonction <code>minMaxTab<\/code>.<\/p>\n<pre><code class=\"language-c\">void minMaxTab(int tab[], int n, int* min, int* max)\n{\n    *min = tab[0];\n    *max = tab[0];\n    for(int i=1; i&lt;n; i++)\n    {\n        if(tab[i] &lt; *min) *min = tab[i];\n        else if(tab[i] &gt; *max) *max = tab[i];\n    }\n}\n<\/code><\/pre>\n<p>Des variantes sont possibles. Par exemple, on pourrait utiliser des variables de type <code>int<\/code> pour la recherche de la plus petite et de la plus grande valeur, et ne placer les r\u00e9sultat dans <code>*min<\/code> et <code>*max<\/code> qu&rsquo;\u00e0 l&rsquo;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\u00e9rente de celle propos\u00e9e, il est important que vous la testiez sur machine ou, si vous participer \u00e0 un enseignement en pr\u00e9sence, que vous demandiez \u00e0 votre enseignant ou votre enseignante de la v\u00e9rifier.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-c-ent2-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement C.ent2.3<\/h4>\n<p>On veut maintenant r\u00e9aliser une fonction <code>fusion<\/code>&#8230;<\/p>\n<pre><code class=\"language-c\">void fusion(const double t1[], int n1, const double t2[], \n            int n2, double t[])\n<\/code><\/pre>\n<p>&#8230;qui admet en param\u00e8tre :<\/p>\n<ul>\n<li>un tableau de <code>double<\/code> d\u00e9sign\u00e9 par <code>t1<\/code>, de longueur au moins \u00e9gale \u00e0 <code>n1<\/code>, dont les valeurs sont suppos\u00e9es \u00eatre tri\u00e9es en ordre croissant,<\/li>\n<li>un tableau de <code>double<\/code> d\u00e9sign\u00e9 par <code>t2<\/code>, de longueur au moins \u00e9gale \u00e0 <code>n2<\/code>, dont les valeurs sont suppos\u00e9es \u00eatre tri\u00e9es en ordre croissant,<\/li>\n<li>un tableau de <code>double<\/code> d\u00e9sign\u00e9 par <code>t<\/code>, de longueur au moins \u00e9gale \u00e0 <code>n1+n2<\/code>, dont le contenu n&rsquo;est pas important car il sera \u00e9cras\u00e9.<\/li>\n<\/ul>\n<p>Le r\u00f4le de cette fonction est de placer dans le tableau d\u00e9sign\u00e9 par <code>t<\/code> la <strong>fusion<\/strong> des deux parties pr\u00e9c\u00e9demment tri\u00e9es du tableau d\u00e9sign\u00e9 par <code>t<\/code>. Cette fusion est une suite croissante de <code>n<\/code> valeurs : on fusionne deux tableaux tri\u00e9s en un seul tableaux tri\u00e9.<\/p>\n<p>Voici, \u00e0 titre d&rsquo;exemple, les premi\u00e8res \u00e9tapes de la fusion de 3, 5, 6 et de 3, 4, 9. Les petites fl\u00e8ches indiquent les positions de deux curseurs permettant de parcourir chacune des deux listes \u00e0 fusionner. Un tiret sous une valeur indique qu&rsquo;elle a d\u00e9j\u00e0 \u00e9t\u00e9 ajout\u00e9e \u00e0 la fusion.<\/p>\n<pre><code class=\"language-plain_text\">          Partie 1                  Partie 2             Fusion\n\u00c9tape 1   3 5 6                     3 4 9    \n          ^                         ^\n\u00c9tape 2   3 5 6                     3 4 9                3\n          - ^                       ^\n\u00c9tape 3   3 5 6                     3 4 9                3 3\n          - ^                       - ^\n\u00c9tape 4   3 5 6                     3 4 9                3 3 4\n          - ^                       - - ^  \n\u00c9tape 5   3 5 6                     3 4 9                3 3 4 5\n          - - ^                     - - ^  \n\u00c9tape 6   3 5 6                     3 4 9                3 3 4 5 6\n          - - - ^                   - - ^  \n\u00c9tape 7   3 5 6                     3 4 9                3 3 4 5 6 9\n          - - - ^                   - - - ^  \n<\/code><\/pre>\n<p>Lorsque l&rsquo;op\u00e9ration de fusion est termin\u00e9e, le r\u00e9sultat doit \u00eatre recopi\u00e9 dans le tableau d\u00e9sign\u00e9 par <code>t<\/code>.<\/p>\n<p>Voici une version partielle de la fonction, \u00e0 compl\u00e9ter.<\/p>\n<pre><code class=\"language-c\">void fusion(const double t1[], int n1, const double t2[], \n            int n2, double t[])\n{\n    int i1 = 0; \/\/ Position dans t1\n    int i2 = 0; \/\/ Position dans t2\n    for(int i=0; i &lt; n1+n2; i++)\n    {\n        \/\/ \u00c0 compl\u00e9ter\n    }\n}\n<\/code><\/pre>\n<p>\u00c0 chaque it\u00e9ration de la boucle, une valeur de <code>t1<\/code> ou une valeur de <code>t2<\/code> doit \u00eatre ajout\u00e9e \u00e0 <code>t<\/code> en position <code>i<\/code>.<\/p>\n<p>La fonction <code>main<\/code> suivante donne un exemple de mise en oeuvre de la fonction <code>fusion<\/code>.<\/p>\n<pre><code class=\"language-c\">int main()\n{\n    double t1[] = {3,5,6};\n    double t2[] = {3,4,9};\n    double t[6];\n    fusion(t1, 3, t2, 3, t);\n    for(int i=0; i&lt;6; i++)\n    {\n        printf(\"%.02f \", t[i]);\n    }\n    printf(\"\\n\");\n    return 0;\n}\n<\/code><\/pre>\n<p>Si la fonction fusion est correctement programm\u00e9e, l&rsquo;affichage produit est :<\/p>\n<pre><code class=\"language-plain_text\">3.00 3.00 4.00 5.00 6.00 9.00 \n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Voici un code un peu plus complet.<\/p>\n<pre><code class=\"language-c\">void fusion(const double t1[], int n1, const double t2[], \n            int n2, double t[])\n{\n    int i1 = 0; \/\/ Position dans t1\n    int i2 = 0; \/\/ Position dans t2\n    for(int i=0; i &lt; n1+n2; i++)\n    {\n        if(i1 &gt;= n1) \n        {\n            \/\/ \u00c0 compl\u00e9ter   Ligne A\n        }\n        else if(i2 &gt;= n2)\n        {\n            \/\/ \u00c0 compl\u00e9ter   Ligne B\n        }\n        else if(t1[i1] &lt; t2[i2]) \n        {\n            \/\/ \u00c0 compl\u00e9ter   Ligne C\n        }\n        else\n        {\n            \/\/ \u00c0 compl\u00e9ter   Ligne D\n        }\n    }\n    printf(\"\\n\");\n}\n<\/code><\/pre>\n<p>La ligne A g\u00e8re le cas o\u00f9 tous les \u00e9l\u00e9ments du tableau d\u00e9sign\u00e9 par <code>t1<\/code> ont \u00e9t\u00e9 consomm\u00e9s. la ligne 2 g\u00e8re le cas o\u00f9 se sont tous les \u00e9l\u00e9ments du tableau d\u00e9sign\u00e9 par t2 qui ont \u00e9t\u00e9 consomm\u00e9s. Les lignes C et D concernent les cas o\u00f9 il reste des valeurs dans les deux tableaux \u00e0 fusionner et o\u00f9 il faut consommer un \u00e9l\u00e9ment d&rsquo;un des deux tableaux.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void fusion(const double t1[], int n1, const double t2[], \n            int n2, double t[])\n{\n    int i1 = 0; \/\/ Position dans t1\n    int i2 = 0; \/\/ Position dans t2\n    for(int i=0; i &lt; n1+n2; i++)\n    {\n        if(i1 &gt;= n1) \n        {\n            t[i] = t2[i2]; i2++;\n        }\n        else if(i2 &gt;= n2)\n        {\n            t[i] = t1[i1]; i1++;\n        }\n        else if(t1[i1] &lt; t2[i2]) \n        {\n            t[i] = t1[i1]; i1++;\n        }\n        else\n        {\n            t[i] = t2[i2]; i2++;\n        }\n    }\n    printf(\"\\n\");\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"it%C3%A9ration-c-ent3\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration C.ent3<\/h3>\n<h4><a id=\"exercice-d-entrainement-c-ent3-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement C.ent3.1<\/h4>\n<p>R\u00e9alisez une fonction nomm\u00e9e <code>sumTab<\/code> qui accepte un param\u00e8tre <code>tab<\/code> d\u00e9signant un tableau d\u2019entiers, et<br \/>\nparam\u00e8tre <code>n<\/code> de type <code>int<\/code>. En supposant que <code>n<\/code> soit la taille du tableau, cette fonction doit retourner un la somme des valeurs du tableau.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int sumTab(int tab[], int n)\n{\n  int sum = 0;\n  \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\n<p>Il reste \u00e0 parcourir le tableau et ajouter la valeur de chaque cellule \u00e0 la variable <code>sum<\/code>, qui sera retourn\u00e9e apr\u00e8s l&rsquo;ex\u00e9cution de la boucle.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int sumTab(int tab[], int n)\n{\n  int sum = 0;\n  for(int i=0; i&lt;n; i++)\n  {\n    sum = sum + tab[i];\n  }\n  return sum;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-c-ent3-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement C.ent3.2<\/h4>\n<p>R\u00e9alisez une fonction&#8230;<\/p>\n<pre><code class=\"language-c\">int valeursPaires(int tab[], int n, int pairs[])\n<\/code><\/pre>\n<p>&#8230;permettant de collecter dans le tableau d\u00e9sign\u00e9 par <code>pairs<\/code> toutes les valeurs paires situ\u00e9es dans les <code>n<\/code> premi\u00e8res cellules du tableau d\u00e9sign\u00e9 par <code>tab<\/code>. On suppose que le tableau d\u00e9sign\u00e9 par <code>tab<\/code> et que celui d\u00e9sign\u00e9 par <code>pairs<\/code> ont une taille au moins \u00e9gale \u00e0 <code>n<\/code>. La fonction retourne le nombre de valeurs paires r\u00e9cup\u00e9r\u00e9es.<\/p>\n<p>Voici un exemple de fonction <code>main<\/code> permettant de tester la fonction \u00e0 r\u00e9aliser. Vous devez compl\u00e9ter cette fonction <code>main<\/code> et d\u00e9terminer ce qu&rsquo;elle doit afficher avant de continuer l&rsquo;exercice.<\/p>\n<pre><code class=\"language-c\">int main()\n{\n  int t[] = {2,5,3,7,1,8,2,3};\n  int collect[8];\n  int nPairs = \/\/ \u00c0 compl\u00e9ter\n  printTabInt(collect, nPairs); \/\/ Pour v\u00e9rification\n  return 0;\n}\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>La ligne \u00e0 comp\u00e9ter est :<\/p>\n<pre><code class=\"language-c\">  int nPairs = valeursPaires(t, 8, collect);\n<\/code><\/pre>\n<p>Les valeurs affich\u00e9es sont <code>2 8 2<\/code>.<\/p>\n<p>Il vous reste \u00e0 d\u00e9finir la fonction <code>valeurspaires<\/code>. Vous pourrez utiliser deux variables, une pour parcourir les indices du tableau \u00e0 parcourir, et l&rsquo;autre, initialis\u00e9e \u00e0 0, pour d\u00e9signer l&rsquo;indice de la prochaine valeur \u00e0 placer dans le tableau destin\u00e9 \u00e0 collecter les valeurs paires.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice2<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Voici une version \u00e0 compl\u00e9ter de la fonction \u00e0 d\u00e9finir.<\/p>\n<pre><code class=\"language-c\">int valeursPaires(int tab[], int n, int pairs[])\n{\n    int k = 0;\n    for(int i=0; i&lt;n; i++)\n    {\n        \/\/ \u00c0 compl\u00e9ter\n    }\n    return k;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int valeursPaires(int tab[], int n, int pairs[])\n{\n    int k = 0;\n    for(int i=0; i&lt;n; i++)\n    {\n        if(tab[i]%2 == 0)\n        {\n            pairs[k] = tab[i];\n            k++;\n        }\n    }\n    return k;\n}\n<\/code><\/pre>\n<p>Comme toujours, votre solution peut \u00eatre diff\u00e9rente sans pour autant \u00eatre incorrecte, mais vous devez lever rapidement tout incertitude. Valider une solution incorrecte est n\u00e9faste \u00e0 un bon apprentissage.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-c-ent3-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement C.ent3.3<\/h4>\n<p>Le triangle de Pascal est construit avec les r\u00e8gles suivantes :<\/p>\n<ul>\n<li>La premi\u00e8re ligne comporte juste la valeur 1.<\/li>\n<li>Chaque ligne suivante commence par 1, puis comporte les sommes de deux valeurs cons\u00e9cutives de la ligne pr\u00e9c\u00e9dente, puis se termine par 1.<\/li>\n<\/ul>\n<pre><code class=\"language-plain_text\">ligne 1 : 1\nligne 2 : 1 1\nligne 3 : 1 2 1\nligne 4 : 1 3 3 1\nligne 5 : 1 4 6 4 1\n...\n<\/code><\/pre>\n<p>Vous devez d\u00e9finir une fonction&#8230;<\/p>\n<pre><code class=\"language-c\"> int getPascal(int ligne[], int k)\n<\/code><\/pre>\n<p>&#8230; qui permet de r\u00e9cup\u00e9rer dans le tableau d\u00e9sign\u00e9 par <code>ligne<\/code> la ligne <code>k<\/code> du triangle de Pascal. On suppose que la taille du tableau est suffisante pour contenir toutes les valeurs de la ligne \u00e0 produire. La valeur de retour est le nombre de valeurs de la ligne produite.<\/p>\n<p>Voici un exemple de fonction <code>main<\/code> permettant de tester la fonction <code>getPascal<\/code>.<\/p>\n<pre><code class=\"language-c\">int main()\n{\n    int tab[10];\n    int n = getPascal(tab, 5);\n    printTabInt(tab,5);\n    return 0;\n}\n<\/code><\/pre>\n<p>L&rsquo;affichage attendu \u00e9tant :<\/p>\n<pre><code class=\"language-plain_text\">1 4 6 4 1\n<\/code><\/pre>\n<p>Le principe du calcul est le suivant. Les lignes sont num\u00e9rot\u00e9es 1, 2, 3, etc., conform\u00e9ment \u00e0 l&rsquo;illustration du triangle de Pascal donn\u00e9e pr\u00e9c\u00e9demment. Pour tout \\(i\\) au moins \u00e9gal \u00e0 1, chaque ligne \\(i\\) comporte \\(i\\) valeurs qui sont stock\u00e9es dans les cellules d&rsquo;indice 0 \u00e0 \\(i-1\\) d&rsquo;un tableau.<\/p>\n<p>Voici un squelette de la d\u00e9finition de la fonction.<\/p>\n<pre><code class=\"language-c\"> int getPascal(int ligne[], int k)\n {\n     \/\/ Tableau pour stocker temporairement chaque nouvelle ligne calcul\u00e9e\n     int nouvelleLigne[k]; \n   \n     \/\/ D\u00e9finition de la premi\u00e8re ligne du triangle\n     nouvelleLigne[0] = 1;  \n   \n     \/\/ Calcul des lignes suivantes jusqu'\u00e0 la ligne k\n     for(int i=2; i &lt;= k; i++)\n     {\n       \/\/ Calcul de la ligne i d'apr\u00e8s les valeurs de la ligne pr\u00e9c\u00e9dente\n       \/\/ situ\u00e9es dans le tableau ligne. Les valeurs de la ligne i sont\n       \/\/ plac\u00e9es dans le tableau nouvelleLigne.\n       \n       \/\/ Recopie des valeurs de la ligne i dans le tableau ligne. \n     }\n }\n<\/code><\/pre>\n<p>On ne stocke pas toutes les lignes du triangle. (D&rsquo;ailleurs nous n&rsquo;avons pas encore introduit les tableaux \u00e0 2 dimensions.) Deux tableaux sont utilis\u00e9s : <code>ligne<\/code>, qui contient la derni\u00e8re ligne produite, et <code>nouvelleLigne<\/code>, dans lequel on place les valeurs de la ligne en cours de calcul. Lorsque le calcul d&rsquo;une nouvelle ligne est termin\u00e9, on recopie ses valeurs dans le tableau <code>ligne<\/code>.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Voici une version encore incompl\u00e8te. Veillez \u00e0 ne pas confondre les variables <code>i<\/code> et <code>j<\/code>. La variable <code>i<\/code> d\u00e9signe la ligne en cours de calcul. La variable <code>j<\/code> d\u00e9signe la position dans la ligne en cours de calcul de la valeur en cours de calcul.<\/p>\n<pre><code class=\"language-c\"> int getPascal(int ligne[], int k)\n {\n     int nouvelleLigne[k];\n     nouvelleLigne[0] = 1;\n     for(int i=2; i &lt;= k; i++)\n     {\/\/ Production de la ligne i dans le tableau nouvelleLigne.\n         nouvelleLigne[0] = 1;\n         for(int j=1; j &lt;= i-2; j++)\n         {\n             \/\/ Calcul d'une valeur de la nouvelle ligne\n             \/\/ \u00c0 compl\u00e9ter\n         }\n         nouvelleLigne[i-1] = 1;\n         \n      \/\/ Recopie le la ligne i dans le tableau ligne.\n         for(int j=0; j &lt; i; j++)\n         {\n             \/\/ \u00c0 compl\u00e9ter\n         }\n     }\n }\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\"> int getPascal(int ligne[], int k)\n {\n     int nouvelleLigne[k];\n     nouvelleLigne[0] = 1;\n     for(int i=2; i &lt;= k; i++)\n     {\/\/ Production de la ligne i dans le tableau nouvelleLigne.\n         nouvelleLigne[0] = 1;\n         for(int j=1; j &lt;= i-2; j++)\n         {\n             nouvelleLigne[j] = ligne[j-1] + ligne[j];\n         }\n         nouvelleLigne[i-1] = 1;\n         \n      \/\/ Recopie le la ligne i dans le tableau ligne.\n         for(int j=0; j &lt; i; j++)\n         {\n             ligne[j] = nouvelleLigne[j];\n         }\n     }\n }\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<h2><a id=\"activit%C3%A9-de-consolidation-c-top\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 de consolidation C.top<\/h2>\n<p>R\u00e9aliser cette activit\u00e9 consiste \u00e0 traiter un des exercices de consolidation propos\u00e9s. Si vous r\u00e9alisez plusieurs fois cette activit\u00e9, laissez passer au moins une semaine entre chaque it\u00e9ration et traitez \u00e0 chaque fois un exercice diff\u00e9rent.<\/p>\n<h3><a id=\"exercice-de-consolidation-c-top1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de consolidation C.top1<\/h3>\n<p>Supposons que nous disposions d&rsquo;une fonction&#8230;<\/p>\n<pre><code class=\"language-c\">void triTab(double tab[], int n)\n<\/code><\/pre>\n<p>&#8230; qui trie en ordre croissant les <code>n<\/code> premi\u00e8res valeurs du tableau d\u00e9sign\u00e9 par <code>tab<\/code> .<\/p>\n<p>Compl\u00e9tez la fonction suivante&#8230;<\/p>\n<pre><code class=\"language-c\">void biTri(double t[], int n, int m)\n<\/code><\/pre>\n<p>&#8230;de mani\u00e8re \u00e0 ce qu&rsquo;elle ait l&rsquo;effet suivant :<\/p>\n<p>On consid\u00e8re que la tableau d\u00e9sign\u00e9 par t est constitu\u00e9 de deux parties. La premi\u00e8re partie comporte les <code>m<\/code> premi\u00e8res valeurs et la seconde partie les valeurs suivantes. L&rsquo;ex\u00e9cution de <code>biTri<\/code> doit trier chacune de ces deux parties. On suppose que <code>m<\/code> est compris entre 0 et <code>n<\/code>. Voici un exemple dans le quel <code>n<\/code> vaut 6 et <code>m<\/code> vaut 3. Les deux tris doivent \u00eatre r\u00e9alis\u00e9s par des appels \u00e0 la fonction <code>triTab<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/7.png\" alt=\"image-20211222121128693\" \/><\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void biTri(double t[], int n, int m)\n{\n    triTab(t,m);\n    triTab(t+m, n-m);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p>La fonction <code>fusion<\/code> d\u00e9finie dans l&rsquo;exercice C.ent2.3 permet de fusionner deux listes d\u00e9j\u00e0 tri\u00e9es, repr\u00e9sent\u00e9es par des tableaux de <code>double<\/code>, et de placer le r\u00e9sultat, qui est une liste tri\u00e9e comportant tous les \u00e9l\u00e9ments des listes initiales, dans un tableau de <code>double<\/code>.<\/p>\n<p>On consid\u00e8re ici que cette fonction <code>fusion<\/code> est d\u00e9j\u00e0 correctement programm\u00e9e.<\/p>\n<pre><code class=\"language-c\">void fusion(const double t1[], int n1, const double t2[], \n            int n2, double t[])\n<\/code><\/pre>\n<p>L&rsquo;une des listes \u00e0 fusionner est constitu\u00e9e des <code>n1<\/code> premiers \u00e9l\u00e9ments du tableau d\u00e9sign\u00e9 par <code>t1<\/code>. L&rsquo;autre est constitu\u00e9e des <code>n2<\/code> premiers \u00e9l\u00e9ments du tableau d\u00e9sign\u00e9 par <code>t2<\/code>. Le r\u00e9sultat est constitu\u00e9 des <code>n1+n2<\/code> premiers \u00e9l\u00e9ments du tableau d\u00e9sign\u00e9 par <code>tab<\/code>. Si vous souhaitez faire des essais sur machine, vous pouvez reprendre le code de cette fonction donn\u00e9 en solution de l&rsquo;exercice C.ent2.3.<\/p>\n<p>En utilisant la fonction <code>fusion<\/code>, vous devez r\u00e9aliser une fonction <strong>r\u00e9cursive<\/strong> nomm\u00e9e <code>triFusion<\/code> permettant de trier les <code>n<\/code> premiers \u00e9l\u00e9ments d&rsquo;un tableau de <code>double<\/code> nomm\u00e9 <code>t<\/code>.<\/p>\n<pre><code class=\"language-c\">void triFusion(double t[], int n)\n<\/code><\/pre>\n<p>Le principe est le suivant :<\/p>\n<ul>\n<li>Si la liste \u00e0 trier a au plus un \u00e9l\u00e9ment, alors elle est d\u00e9j\u00e0 tri\u00e9e et il n&rsquo;y a rien de particulier \u00e0 faire.<\/li>\n<li>Sinon, cette liste est s\u00e9par\u00e9e en 2 parties de tailles similaires qui sont tri\u00e9es s\u00e9par\u00e9ment par des appels r\u00e9cursifs \u00e0 la fonction <code>triFusion<\/code>, puis les r\u00e9sultats sont fusionn\u00e9s en une seule liste.<\/li>\n<\/ul>\n<p>Voici un sch\u00e9ma d\u00e9taillant les \u00e9tapes d&rsquo;un tri fusion.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/8.png\" alt=\"image-20211223192828714\" \/><\/p>\n<p>Votre mission consiste \u00e0 compl\u00e9ter la d\u00e9finition de <code>triFusion<\/code> donn\u00e9e ci-dessous.<\/p>\n<pre><code class=\"language-c\">void triFusion(double t[], int n)\n{\n    if(n &lt;= 1) return;\n    int m = n \/ 2;\n    double tabTmp[n];\n    \/\/ Appels r\u00e9curfifs\n    fusion(\/* \u00c0 compl\u00e9ter *\/);\n    for(int i=0; i&lt;n; i++)        \/\/ Ligne A\n    {\n        t[i] = tabTmp[i];\n    }                             \/\/ Ligne B\n}\n<\/code><\/pre>\n<p>La partie situ\u00e9e entre le ligne A et la ligne B permet de recopier le r\u00e9sultat du tri dans le tableau qui contenait initialement les valeurs \u00e0 trier. Cela n&rsquo;a rien d&rsquo;anecdotique. Si le r\u00e9sultat de la fusion n&rsquo;\u00e9tait pas plac\u00e9 dans un tableau interm\u00e9diaire avant d&rsquo;\u00eatre recopi\u00e9 dans le tableau d&rsquo;origine, des valeurs seraient \u00e9cras\u00e9es avant d&rsquo;\u00eatre exploit\u00e9es pour la fusion et le tri \u00e9chouerait.<\/p>\n<p>Voici un exemple d&rsquo;utilisation de la fonction.<\/p>\n<pre><code class=\"language-c\">int main()\n{\n    double tab[] = {5,6,3,4,9,3};\n    triFusion(tab,6);\n    for(int i=0; i&lt;6; i++)\n    {\n        printf(\"%.02f \", tab[i]);\n    }\n    printf(\"\\n\");\n    return 0;\n}\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Voici une version avec les appels r\u00e9cursifs.<\/p>\n<pre><code class=\"language-c\">void triFusion(double t[], int n)\n{\n    if(n &lt;= 1) return;\n    int m = n \/ 2;\n    double tabTmp[n];\n    triFusion(t,m);\n    triFusion(t+m,n-m);\n    fusion(\/* \u00c0 compl\u00e9ter *\/);\n    for(int i=0; i&lt;n; i++)        \/\/ Ligne A\n    {\n        t[i] = tabTmp[i];\n    }                             \/\/ Ligne B\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void triFusion(double t[], int n)\n{\n    if(n &lt;= 1) return;\n    int m = n \/ 2;\n    double tabTmp[n];\n    triFusion(t,m);\n    triFusion(t+m,n-m);\n    fusion(t,m,t+m,n-m,tabTmp);\n    for(int i=0; i&lt;n; i++)\n    {\n        t[i] = tabTmp[i];\n    }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"exercice-de-consolidation-c-top2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de consolidation C.top2<\/h3>\n<p>Le but de cet exercice est de r\u00e9aliser une fonction permettant de calculer efficacement le nombre maximum d&rsquo;occurrences d&rsquo;une valeur dans un tableau de valeurs de type <code>uint8_t<\/code>. Prenons un exemple. Si le tableau \u00e0 analyser contient les valeurs&#8230;<\/p>\n<pre><code class=\"language-plain_text\"> 1, 2, 3, 5, 6, 1, 2, 4, 5, 9, 45, 25, 12, 5, 3\n<\/code><\/pre>\n<p>&#8230; alors le nombre maximum d&rsquo;occurrence d&rsquo;une valeur est 3. En effet, la valeur 5 apparait trois fois et aucune autre valeur n&rsquo;apparait plus souvent.<\/p>\n<p>Une solution serait de parcourir le tableau \u00e0 l&rsquo;aide d&rsquo;une boucle et, pour chaque valeur trouv\u00e9e, de compter son nombre d&rsquo;occurrences \u00e0 l&rsquo;aide d&rsquo;une seconde boucle. Mais cela n\u00e9cessite d&rsquo;utiliser une boucle imbriqu\u00e9e dans une autre, avec pour cons\u00e9quence un temps d&rsquo;ex\u00e9cution proportionnel au carr\u00e9 de la taille du tableau \u00e0 analyser.<\/p>\n<p>Le challenge propos\u00e9 ici est de r\u00e9aliser un programme ne comportant pas de boucles imbriqu\u00e9es, mais un nombre limit\u00e9 de boucles successives, qui produit l&rsquo;information recherch\u00e9e en temps lin\u00e9aire. En contrepartie d&rsquo;une ex\u00e9cution rapide, la fonction \u00e0 r\u00e9aliser devra utiliser un tableau temporaire (local) d&rsquo;entiers comportant 256 cellules.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\"> int maxFrequ(uint8_t tab[], int n)\n {\n    int compteurs[256] = {0};\n    \/\/ \u00c0 compl\u00e9ter\n    int maxOcc = 0;\n    \/\/ \u00c0 compl\u00e9ter\n    return maxOcc;\n }\n<\/code><\/pre>\n<p>Le tableau <code>compteurs<\/code> doit contenir, apr\u00e8s ex\u00e9cution de la premi\u00e8re partie \u00e0 compl\u00e9ter, le nombre d&rsquo;occurrences de chaque valeur comprise entre 0 et 255 dans le tableau <code>tab<\/code> : <code>compteurs[0]<\/code> doit contenir le nombre d&rsquo;occurrence de la valeur 0 dans <code>tab<\/code>, <code>compteurs[1]<\/code> doit contenir le nombre d&rsquo;occurrence de la valeur 1 dans <code>tab<\/code>, etc.<\/p>\n<p>La deuxi\u00e8me partie \u00e0 compl\u00e9ter doit rechercher la plus grande valeur du tableau <code>compteurs<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\"> int maxFrequ(uint8_t tab[], int n)\n {\n    int compteurs[256] = {0};\n    for(int i=0; i&lt;n; i++)\n    {\n        compteurs[tab[i]]++;\n    }\n    int maxOcc = 0;\n    for(int i=0; i&lt;256; i++)\n    {\n        if(compteurs[i] &gt; maxOcc)\n        {\n            maxOcc = compteurs[i];\n        }\n    }\n    return maxOcc;\n }\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n","protected":false},"excerpt":{"rendered":"<p>Par O. Bailleux, Ma\u00eetre de conf\u00e9rences HDR \u00e0 l&rsquo;universit\u00e9 de Bourgogne. Tableaux et pointeurs Les activit\u00e9s #.dec (dec pour D\u00e9couverte) consistent \u00e0 \u00e9tudier des pr\u00e9sentations explicatives et \u00e0 traiter tous les exercices de d\u00e9couverte propos\u00e9s. Si vous ne r\u00e9pondez pas correctement \u00e0 un exercice de d\u00e9couverte, revenez en arri\u00e8re pour relire les explications et identifier [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[2],"tags":[],"class_list":["post-44","post","type-post","status-publish","format-standard","hentry","category-c-et-cpp","entry"],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/44","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/comments?post=44"}],"version-history":[{"count":3,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/44\/revisions"}],"predecessor-version":[{"id":208,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/44\/revisions\/208"}],"wp:attachment":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/media?parent=44"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/categories?post=44"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/tags?post=44"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}