{"id":151,"date":"2022-01-22T20:56:08","date_gmt":"2022-01-22T20:56:08","guid":{"rendered":"https:\/\/9h15.net\/activ\/?p=151"},"modified":"2022-02-21T11:33:57","modified_gmt":"2022-02-21T11:33:57","slug":"c-et-c-partie-e","status":"publish","type":"post","link":"https:\/\/9h15.net\/activ\/c-et-c-partie-e\/","title":{"rendered":"C et C++ partie E"},"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-dynamiques\" class=\"anchor\" aria-hidden=\"true\"><\/a>Tableaux dynamiques<\/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-e-dec\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 de d\u00e9couverte E.dec<\/h2>\n<h3><a id=\"e-dec1-tableau-dynamique\" class=\"anchor\" aria-hidden=\"true\"><\/a>E.dec1 : Tableau dynamique<\/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 la partie C (tableaux et pointeurs) et la partie D (cha\u00eenes de caract\u00e8res)<\/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>Cr\u00e9er un tableau pouvant \u00eatre d\u00e9truit lorsqu&rsquo;on en a plus besoin.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Dans la partie C, nous avons vu deux sortes de tableaux :<\/p>\n<ul>\n<li><strong>Les tableaux globaux<\/strong>, qui sont cr\u00e9\u00e9s en d\u00e9but de l&rsquo;ex\u00e9cution du programme et existent pendant toute la dur\u00e9e de son ex\u00e9cution. Ils peuvent \u00eatre tr\u00e8s grands (taille limit\u00e9e par la m\u00e9moire disponible) et sont accessibles par toutes les fonctions du programme.<\/li>\n<li><strong>Les tableaux locaux<\/strong> qui n&rsquo;existent que pendant l&rsquo;ex\u00e9cution de la fonction dans laquelle ils sont d\u00e9clar\u00e9s et ne sont accessibles que dans cette fonction o\u00f9 dans une autre fonction qui \u00e0 acc\u00e8s \u00e0 leur adresse m\u00e9moire. La taille d&rsquo;un tableau local est limit\u00e9e par celle de la pile d&rsquo;ex\u00e9cution.<\/li>\n<\/ul>\n<p>Mais il arrive qu&rsquo;on souhaite utiliser un tableau de taille arbitrairement grande (dans la limite de la m\u00e9moire disponible) pendant une dur\u00e9e qui n&rsquo;est ni celle de l&rsquo;ex\u00e9cution du programme, ni celle de l&rsquo;ex\u00e9cution d&rsquo;une fonction particuli\u00e8re. Typiquement, un tableau cr\u00e9\u00e9 dans une fonction et d\u00e9truit dans une autre.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>R\u00e9servation d&rsquo;un bloc m\u00e9moire dans le tas<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Il existe une zone m\u00e9moire que nous n&rsquo;avons encore jamais utilis\u00e9e et qui est appel\u00e9e <strong>le tas<\/strong> (Heap en anglais). Il est possible de r\u00e9server dans cette zone des blocs m\u00e9moire pouvant notamment \u00eatre utilis\u00e9s comme des tableaux. Voici un exemple de fonction qui cr\u00e9e dans le tas une cha\u00eene de caract\u00e8re contenant la concat\u00e9nation de deux cha\u00eenes pass\u00e9es en arguments.<\/p>\n<pre><code class=\"language-C\">char* concat(const char* s1, const char* s2)\n{\n    int n1 = strlen(s1);                     \n    int n2 = strlen(s2);\n    char* out = (char*) malloc((n1+n2+1)*sizeof(char));  \/\/ A\n    strcpy(out, s1);                                     \/\/ B\n    strcpy(out + n1, s2);                                \/\/ C\n    return out;                                          \/\/ D\n}\n<\/code><\/pre>\n<p>La fonction <code>main<\/code> suivante donne un exemple d&rsquo;utilisation.<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    char t[] = \"Tim \";\n    char u[] = \"et Tom\";\n    char* s = concat(t, u);\n    printf(\"%s\\n\", s);\n    return 0;\n}\n<\/code><\/pre>\n<p>Il y a beaucoup de choses \u00e0 dire \u00e0 propos de cet exemple. La premi\u00e8re est que, contrairement \u00e0 la fonction standard <code>strcat<\/code>, la fonction <code>concat<\/code> cr\u00e9e une nouvelle cha\u00eene, ind\u00e9pendante des deux cha\u00eenes d\u00e9sign\u00e9es par les param\u00e8tres <code>s1<\/code> et <code>s2<\/code>, et qui est stock\u00e9e dans une nouvelle zone m\u00e9moire situ\u00e9e dans le tas.<\/p>\n<p>Le bloc m\u00e9moire contenant la cha\u00eene retourn\u00e9e par <code>concat<\/code> est r\u00e9serv\u00e9 dans le tas par un appel, <strong>en ligne A<\/strong>, \u00e0 la fonction standard <code>malloc<\/code>, dont le nom est une abr\u00e9viation de \u00ab\u00a0memory allocation\u00a0\u00bb.<\/p>\n<pre><code class=\"language-C\">void* malloc( size_t size );\n<\/code><\/pre>\n<p>Cette fonction r\u00e9serve un bloc m\u00e9moire de la taille indiqu\u00e9e en param\u00e8tre et en retourne l&rsquo;adresse. Si la r\u00e9servation est impossible, la valeur de retour est <code>NULL<\/code>. Cela se produit seulement quand il ne reste plus de zone m\u00e9moire de la taille demand\u00e9e, soit parce que toute la m\u00e9moire \u00e0 \u00e9t\u00e9 utilis\u00e9e, soit parce qu&rsquo;elle est fragment\u00e9e.<\/p>\n<p>La valeur de retour de <code>malloc<\/code> est de type <code>void*<\/code>, qu&rsquo;on pourrait traduire par \u00ab\u00a0pointeur sur n&rsquo;importe quoi\u00a0\u00bb. En effet, <code>malloc<\/code> peut \u00eatre utilis\u00e9e pour r\u00e9server des blocs permettant de stocker n&rsquo;importe quel type de donn\u00e9es. Un <strong>cast<\/strong>, aussi appel\u00e9 transtypage, est n\u00e9cessaire pour placer l&rsquo;adresse du bloc dans la variable <code>out<\/code> qui est de type pointeur sur <code>char<\/code>. D\u00e8s lors, ce bloc pourra \u00eatre utilis\u00e9 comme un tableau de caract\u00e8res, et donc contenir une cha\u00eene.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-e-dec-x1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte E.dec.x1<\/h5>\n<p>Pourquoi la taille du bloc est-elle \u00e9gale \u00e0 1 plus la somme des tailles des cha\u00eenes d\u00e9sign\u00e9es par les param\u00e8tres ?<\/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 bloc doit recevoir la concat\u00e9nation des cha\u00eenes d\u00e9sign\u00e9es en param\u00e8tres. Il faut que sa taille permette le stockage des caract\u00e8res de ces deux cha\u00eenes plus le marqueur de fin de cha\u00eene.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>L&rsquo;ex\u00e9cution de la ligne A place donc dans la variable <code>out<\/code> l&rsquo;adresse d&rsquo;un bloc m\u00e9moire de <code>n1 + n2 + 1<\/code> octets situ\u00e9 dans le tas.<\/p>\n<pre><code class=\"language-C\">    char* out = (char*) malloc((n1+ n2+1)*sizeof(char)); \/\/ A\n<\/code><\/pre>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/1-7.png\" alt=\"image-20220118094830678\" \/><\/p>\n<p>Le bloc retourn\u00e9 par malloc n&rsquo;est pas initialis\u00e9. Son contenu est impr\u00e9visible.<\/p>\n<p>En vertu de la correspondance entre tableaux et pointeurs, l&rsquo;adresse du bloc peut \u00eatre utilis\u00e9e comme un nom de tableau et le bloc peut \u00eatre utilis\u00e9 comme un tableau.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-e-dec-x2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte E.dec.x2<\/h5>\n<p>Donnez les lignes de code \u00e0 ajouter juste apr\u00e8s la ligne A pour initialiser \u00e0 <code>0xFF<\/code> tous les octets du bloc venant d&rsquo;\u00eatre r\u00e9serv\u00e9.<\/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\">    for(int i=0; i&lt; n1+n2+1; i++)\n    {\n        out[i] = 0xFF;\n    }\n<\/code><\/pre>\n<p>Le tableau dynamique s&rsquo;utilise strictement de le m\u00eame mani\u00e8re que les tableaux que nous avons vu jusqu&rsquo;ici.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Le reste de la d\u00e9finition de la fonction <code>concat<\/code> fait appel aux connaissances abord\u00e9es pr\u00e9c\u00e9demment. On copie bout \u00e0 bout les cha\u00eenes \u00e0 concat\u00e9ner dans le nouveau bloc m\u00e9moire, dont l&rsquo;adresse est ensuite retourn\u00e9e.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-e-dec-x3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte E.dec.x3<\/h5>\n<p>La compilation de la fonction suivante, cens\u00e9e avoir le m\u00eame r\u00f4le que la version pr\u00e9c\u00e9dente, produit un avertissement.<\/p>\n<pre><code class=\"language-C\">char* concat(const char* s1, const char* s2)\n{\n    int n1 = strlen(s1);                     \n    int n2 = strlen(s2);\n    char out[n1 + n2 + 1];\n    strcpy(out, s1);            \n    strcpy(out + n1, s2);       \n    return out;         \n}\n<\/code><\/pre>\n<p>Qu&rsquo;est-ce qui ne va pas avec 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>Le tableau <code>out<\/code> est une variable locale. Contrairement \u00e0 un tableau dynamique r\u00e9serv\u00e9 dans le tas, ce tableau local est d\u00e9truit \u00e0 l&rsquo;issue de l&rsquo;ex\u00e9cution de la fonction. Son utilisation ult\u00e9rieure peut avoir des cons\u00e9quences impr\u00e9visibles et entra\u00eener de graves probl\u00e8mes tels que plantage, \u00e9crasement des valeurs de certaines variables&#8230;<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<h5><a id=\"exercice-de-d%C3%A9couverte-e-dec-x4\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte E.dec.x4<\/h5>\n<p>La cr\u00e9ation de la cha\u00eene retourn\u00e9e par la fonction <code>concat<\/code> est r\u00e9alis\u00e9e par ces deux lignes :<\/p>\n<pre><code class=\"language-C\">    strcpy(out, s1);            \n    strcpy(out + n1, s2);   \n<\/code><\/pre>\n<p>On aurait pu la r\u00e9aliser comme ceci :<\/p>\n<pre><code class=\"language-C\">    strcpy(out, s1);            \n    strcat(out, s2); \n<\/code><\/pre>\n<p>Quel est l&rsquo;int\u00e9r\u00eat de la premi\u00e8re solution par rapport \u00e0 la deuxi\u00e8me ?<\/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>La fonction <code>strcat<\/code> doit d&rsquo;abord localiser le marqueur de fin de la cha\u00eene de destination avant de commencer \u00e0 recopier \u00e0 la suite la cha\u00eene d\u00e9sign\u00e9e par <code>s2<\/code>. La premi\u00e8re version est plus efficace, bien que la diff\u00e9rence ne soit pas visible en pratique.<\/p>\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>R\u00e9server un bloc initialis\u00e9 \u00e0 0 avec calloc<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Nous avons vu que la fonction <code>malloc<\/code> n&rsquo;initialise pas le bloc qu&rsquo;elle r\u00e9serve dans le tas. Il existe une autre fonction permettant de r\u00e9server un bloc et de le remplir avec des valeurs 0.<\/p>\n<pre><code class=\"language-C\">void* calloc( size_t elementCount, size_t elementSize );\n<\/code><\/pre>\n<p>La taille du bloc r\u00e9serv\u00e9 est \u00e9gale \u00e0 <code>elementCount * elementSize<\/code>. Ce bloc est initialis\u00e9 avec des octets <code>0x00<\/code>. Par exemple, la ligne suivante&#8230;<\/p>\n<pre><code class=\"language-C\">int* tab = (int*)calloc(6, sizeof(int));\n<\/code><\/pre>\n<p>&#8230;r\u00e9serve un bloc m\u00e9moire utilisable comme un tableau d&rsquo;entiers de 6 cellules contenant initialement chacune le valeur 0. Ces cellules sont accessibles avec la notation habituelle <code>tab[0]<\/code>, <code>tab[1]<\/code>, &#8230; <code>tab[5]<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/2-6.png\" alt=\"image-20220118112829867\" \/><\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-e-dec-x5\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte E.dec.x5<\/h5>\n<p>Donnez les lignes de code permettant de cr\u00e9er un tableau dynamique de <code>double<\/code> de taille 10 initialis\u00e9 avec des valeurs 0.0<\/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\">    double* t1 = (double*)calloc(10,sizeof(double));\n<\/code><\/pre>\n<p>Comme la valeur double 0.0 est constitu\u00e9e d&rsquo;octets 0, le tableau dynamique est initialis\u00e9 avec des valeurs 0.0.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-e-dec-x6\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte E.dec.x6<\/h5>\n<p>Donnez les lignes de code permettant de cr\u00e9er un tableau dynamique de <code>double<\/code> de taille 10 initialis\u00e9 avec des valeurs 1.0.<\/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\">    double* t2 = (double*)malloc(10*sizeof(double));\n    for(int i=0; i&lt;10; i++) t2[i] = t1.0;\n<\/code><\/pre>\n<p>Il aurait \u00e9t\u00e9 dommage d&rsquo;utiliser <code>calloc<\/code>, qui prend du temps \u00e0 remplir le bloc de 0, alors qu&rsquo;imm\u00e9diatement apr\u00e8s on va remplie le tableau dynamique avec des valeurs 1.0.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"e-dec2-gestion-de-la-m%C3%A9moire\" class=\"anchor\" aria-hidden=\"true\"><\/a>E.dec2 : Gestion de la m\u00e9moire<\/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 C et section pr\u00e9c\u00e9dente<\/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>Utiliser de mani\u00e8re rationnelle la m\u00e9moire en fonction des besoins<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Dans la section pr\u00e9c\u00e9dente, nous avons vu comment cr\u00e9er des tableaux dynamiques. Mais pour ne pas gaspiller de la m\u00e9moire, il est important de <strong>lib\u00e9rer<\/strong> tout bloc m\u00e9moire qui n&rsquo;est plus utilis\u00e9.<\/p>\n<p>On peut pr\u00e9senter les choses de la mani\u00e8re suivante :<\/p>\n<ul>\n<li>\u00c0 chaque fois qu&rsquo;un bloc m\u00e9moire est r\u00e9serv\u00e9 par un appel \u00e0 <code>calloc<\/code> ou <code>malloc<\/code>, on contracte une <strong>dette m\u00e9moire<\/strong>.<\/li>\n<li>Cette dette doit \u00eatre rembours\u00e9e en lib\u00e9rant chaque bloc ayant \u00e9t\u00e9 r\u00e9serv\u00e9.<\/li>\n<\/ul>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>La fonction free<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Tout bloc m\u00e9moire r\u00e9serv\u00e9 avec <code>calloc<\/code> ou <code>malloc<\/code> doit \u00eatre lib\u00e9r\u00e9 avec <code>free<\/code>. Un bloc ne doit \u00eatre lib\u00e9r\u00e9 qu&rsquo;une seule fois. Dans la suite, une tentative d&rsquo;utiliser free \u00e0 mauvais escient, comme par exemple avec une adresse ne correspondant pas \u00e0 un bloc r\u00e9serv\u00e9 dans le tas ou \u00e0 un bloc d\u00e9j\u00e0 lib\u00e9r\u00e9, sera appel\u00e9e <strong>accident m\u00e9moire<\/strong>. Ce type de situation provoque souvent un plantage du programme.<\/p>\n<pre><code class=\"language-C\">void free( void* pointer );\n<\/code><\/pre>\n<p>Observons cet exemple d&rsquo;utilisation de la fonction <code>concat<\/code> d\u00e9finie dans la section pr\u00e9c\u00e9dente.<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    char* s = concat(\"Tim \", \"et Tom \");    \/\/ Ligne A\n    s = concat(s, \"sont sur un bateau.\\n\"); \/\/ Ligne B\n    printf(\"%s\\n\", s);\n    return 0;\n}\n<\/code><\/pre>\n<p>Chaque <code>concat<\/code> r\u00e9serve un bloc m\u00e9moire dans le tas, mais aucun de ces blocs n&rsquo;est lib\u00e9r\u00e9 explicitement. On a ce qu&rsquo;on appelle une fuite m\u00e9moire. Les blocs sont automatiquement lib\u00e9r\u00e9s \u00e0 l&rsquo;issue de l&rsquo;ex\u00e9cution du programme, mais les <strong>bonnes pratiques de programmation<\/strong> imposent qu&rsquo;ils soit lib\u00e9r\u00e9s <strong>avant<\/strong> la fin de l&rsquo;ex\u00e9cution, par utilisation de <code>free<\/code>.<\/p>\n<p>Avant de corriger notre programme, examinons ce qui se passe en m\u00e9moire apr\u00e8s l&rsquo;ex\u00e9cution de la <strong>ligne A<\/strong> et apr\u00e8s l&rsquo;ex\u00e9cution de la <strong>ligne B<\/strong>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/3-6.png\" alt=\"image-20220118124846858\" \/><\/p>\n<p>On voit que le premier bloc, qui contient la cha\u00eene <code>\"Tim et Tom \"<\/code>, n&rsquo;a pas \u00e9t\u00e9 lib\u00e9r\u00e9 avant que l&rsquo;adresse du deuxi\u00e8me soit plac\u00e9e dans la variable <code>s<\/code>. En plus, l&rsquo;adresse de ce bloc a \u00e9t\u00e9 perdue, \u00e9cras\u00e9e dans <code>s<\/code> par celle du nouveau bloc, il ne pourrait donc plus \u00eatre lib\u00e9r\u00e9 par <code>free<\/code>, m\u00eame si on le voulait. On dit qu&rsquo;il y a une <strong>fuite m\u00e9moire<\/strong> lorsqu&rsquo;un bloc m\u00e9moire est r\u00e9serv\u00e9 dans le tas et n&rsquo;est jamais lib\u00e9r\u00e9 par <code>free<\/code>.<\/p>\n<p>Voici la bonne mani\u00e8re de proc\u00e9der pour obtenir le m\u00eame r\u00e9sultat, c&rsquo;est \u00e0 dire une cha\u00eene obtenue par la concat\u00e9nation de <code>\"Tim \"<\/code>, <code>\"et Tom \"<\/code> et <code>\"sont sur un bateau\"<\/code> point\u00e9e par <code>s<\/code>, qui est affich\u00e9e \u00e0 l&rsquo;\u00e9cran.<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    char* s = concat(\"Tim \", \"et Tom \");\n    char* t = concat(s, \"sont sur un bateau.\\n\");\n    free(s);\n    printf(\"%s\\n\", t);\n    free(t);\n    return 0;\n}\n<\/code><\/pre>\n<p>La premi\u00e8re cha\u00eene produite par <code>concat<\/code> est point\u00e9e par <code>s<\/code>. On doit en garder l&rsquo;adresse pour pouvoir lib\u00e9rer ult\u00e9rieurement la m\u00e9moire qu&rsquo;elle occupe dans le tas. On place donc le r\u00e9sultat du deuxi\u00e8me appel de <code>concat<\/code> dans une nouvelle variable <code>t<\/code>. On peut lib\u00e9rer le premier bloc, puis utiliser le deuxi\u00e8me, point\u00e9 par <code>t<\/code>. Une fois qu&rsquo;on en a plus besoin on lib\u00e8re la m\u00e9moire qu&rsquo;il occupe dans le tas.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-e-dec-x7\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte E.dec.x7<\/h5>\n<p>Tentez d&rsquo;identifier le probl\u00e8me dans le programme suivant.<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    char* s = malloc(10 * sizeof(char)); \/\/ Ligne A\n    s = \"Bonjour\";                       \/\/ Ligne B\n    printf(\"%s\\n\", s);                   \/\/ Ligne B\n    free(s);                             \/\/ Ligne C\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>On a une fuite m\u00e9moire et un accident m\u00e9moire. Apr\u00e8s ex\u00e9cution de la ligne A, la variable <code>s<\/code> pointe un bloc m\u00e9moire r\u00e9serv\u00e9 dans le tas. Mais imm\u00e9diatement apr\u00e8s, en ligne B, la variable s re\u00e7oit l&rsquo;adresse d&rsquo;une cha\u00eene situ\u00e9e dans la zone m\u00e9moire r\u00e9serv\u00e9e aux constantes.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/4-7.png\" alt=\"image-20220118180236919\" \/><\/p>\n<p><strong>L&rsquo;instruction <code>s = \"Bonjour\"<\/code> ne copie pas <code>\"Bonjour\"<\/code> dans le bloc m\u00e9moire d\u00e9sign\u00e9 par <code>s<\/code><\/strong>. Pour cel\u00e0 il faudrait utiliser <code>strcpy<\/code>. Elle copie l&rsquo;adresse de la cha\u00eene <code>\"Bonjour\"<\/code> dans la variable <code>s<\/code>. La ligne B s&rsquo;ex\u00e9cute sans probl\u00e8me et affiche \u00ab\u00a0Bonjour\u00a0\u00bb, mais la ligne C tente de lib\u00e9rer un bloc m\u00e9moire qui n&rsquo;est pas dans le tas et n&rsquo;est pas celui r\u00e9serv\u00e9 par <code>malloc<\/code>. On a donc <strong>accident m\u00e9moire<\/strong>. Et comme le bloc r\u00e9serv\u00e9 par <code>malloc<\/code> &lsquo;est pas lib\u00e9r\u00e9 par un appel \u00e0 free, on a une <strong>fuite m\u00e9moire<\/strong>.<\/p>\n<p>Voici une version correcte du programme :<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    char* s = malloc(10 * sizeof(char)); \/\/ Ligne A\n    strcpy(s, \"Bonjour\");                \/\/ Ligne B\n    printf(\"%s\\n\", s);                   \/\/ Ligne B\n    free(s);                             \/\/ Ligne C\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>Changer la taille d&rsquo;un tableau avec realloc<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>La fonction standard <code>realloc<\/code> permet de modifier la taille d&rsquo;un bloc d\u00e9j\u00e0 r\u00e9serv\u00e9. Seuls les bloc r\u00e9serv\u00e9s dans le tas peuvent \u00eatre redimensionn\u00e9s. Redimensionner un bloc ne change pas la dette m\u00e9moire associ\u00e9e. Le bloc devra \u00eatre lib\u00e9r\u00e9, une seule fois, par un appel de la fonction <code>free<\/code>.<\/p>\n<pre><code class=\"language-C\">void* realloc( void* pointer, size_t memorySize );\n<\/code><\/pre>\n<p>Le premier param\u00e8tre est l&rsquo;adresse du bloc \u00e0 redimensionner. Si sa valeur est <code>NULL<\/code>, alors <code>realloc<\/code> r\u00e9serve un nouveau bloc, comme le ferait <code>malloc<\/code>. Le deuxi\u00e8me param\u00e8tre est la nouvelle taille du bloc. Elle peut \u00eatre plus petite ou plus grande que la taille pr\u00e9c\u00e9dente.<\/p>\n<p><strong>Attention<\/strong>, cette op\u00e9ration peut d\u00e9placer le bloc et donc changer son adresse. La valeur de retour est la nouvelle adresse du bloc. Si le bloc est d\u00e9plac\u00e9, sont ancien contenu est recopi\u00e9 au nouvel emplacement.<\/p>\n<p>Cet exemple montre comment on utilise <code>realloc<\/code> pour augmenter la taille d&rsquo;un bloc.<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    char* s = malloc(4*sizeof(char)); \/\/ Ligne A\n    strcpy(s, \"aaa\");                 \/\/ Ligne B\n    s = realloc(s, 7*sizeof(char));   \/\/ Ligne C\n    strcat(s, \"bbb\");                 \/\/ Ligne D\n    printf(\"%s\\n\", s);   \n    free(s);                          \/\/ Ligne E\n}\n<\/code><\/pre>\n<p><strong>En ligne A<\/strong>, on r\u00e9serve un bloc m\u00e9moire dans lequel est recopi\u00e9 en <strong>ligne B<\/strong> la cha\u00eene <code>\"aaa\"<\/code>. On note que ce bloc doit avoir une taille permettant de stocker 4 caract\u00e8res, en comptant le marqueur de fin.<\/p>\n<p><strong>En ligne C<\/strong>, on augmente la taille du bloc point\u00e9 par <code>s<\/code>, de mani\u00e8re \u00e0 pouvoir conc\u00e9t\u00e9ner, en <strong>ligne D<\/strong>, la cha\u00eene <code>\"bbb\"<\/code> \u00e0 celle initialement contenue dans le bloc.<\/p>\n<p><strong>En ligne E<\/strong>, la m\u00e9moire occup\u00e9e par le bloc est lib\u00e9r\u00e9e.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-e-dec-x8\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte E.dec.x8<\/h5>\n<p>Voici une variante du programme pr\u00e9c\u00e9dent qui pose probl\u00e8me. Identifiez s&rsquo;il y a fuite ou accident m\u00e9moire et expliquez pourquoi.<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    char* s = malloc(4*sizeof(char));     \/\/ Ligne A\n    strcpy(s, \"aaa\");                     \/\/ Ligne B\n    char* t = realloc(s, 7*sizeof(char)); \/\/ Ligne C\n    strcat(s, \"bbb\");                     \/\/ Ligne D\n    printf(\"%s\\n\", t);   \n    free(s);                              \/\/ Ligne E\n    free(t);                              \/\/ Ligne F\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>Deux sc\u00e9narios sont envisageables et conduisent tous les deux \u00e0 un accident m\u00e9moire.<\/p>\n<p>Soit <code>realloc<\/code> ne change pas l&rsquo;adresse du bloc. Dans ce cas, les variables <code>t<\/code> et <code>s<\/code> pointent le m\u00eame bloc, qui sera d\u00e9truit deux fois. On a donc un accident m\u00e9moire.<\/p>\n<p>Soit la r\u00e9allocation change l&rsquo;adresse du bloc, alors <code>t<\/code> pointe le nouvel emplacement et <code>free(t)<\/code> lib\u00e9rera correctement la m\u00e9moire. Mais <code>s<\/code> pointera l&rsquo;ancien emplacement o\u00f9 ne se trouve plus de bloc r\u00e9serv\u00e9. L&rsquo;appel <code>free(s)<\/code> provoquera un accident m\u00e9moire.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"e-dec3-tableau-dynamique%C3%A0-2-dimensions\" class=\"anchor\" aria-hidden=\"true\"><\/a>E.dec3 : Tableau dynamique \u00e0 2 dimensions<\/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>Parties C et D et section pr\u00e9c\u00e9dentes de cette partie E.<\/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>Exploiter des tableaux \u00e0 2 dimensions situ\u00e9 dans le tas<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Jusqu&rsquo;\u00e0 maintenant, nous n&rsquo;avons utilis\u00e9 que des tableau \u00e0 une dimension. Il existe plusieurs mani\u00e8res de g\u00e9rer en C des tableaux \u00e0 plusieurs dimensions. L&rsquo;approche native consiste \u00e0 repr\u00e9senter de tels tableaux par un seul bloc m\u00e9moire. Elle est compliqu\u00e9e et manque de souplesse. Nous ne l&rsquo;aborderons pas dans cet enseignement. Nous allons adopter une approche plus moderne, comparable \u00e0 celle utilis\u00e9e par le langage <code>Java<\/code>.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Utiliser un tableau de pointeurs sur des tableaux<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Nous allons pr\u00e9senter le principe utilis\u00e9 avec un exemple dans lequel on repr\u00e9sente des matrices carr\u00e9es de dimension 3 qui pourraient \u00eatre utilis\u00e9es pour mod\u00e9liser des transformations g\u00e9om\u00e9triques.<\/p>\n<p>Pour \u00e9viter d&rsquo;utiliser une constante num\u00e9rique litt\u00e9rale et pour pouvoir modifier facilement la dimension de nos matrices, nous d\u00e9finissions la constante :<\/p>\n<pre><code class=\"language-C\">#define DIM 3\n<\/code><\/pre>\n<p>Voici la repr\u00e9sentation en m\u00e9moire d&rsquo;un tableau de 3 lignes et 3 colonnes.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/5-6.png\" alt=\"image-20220119125719612\" \/><\/p>\n<p>La variable <code>m<\/code> d\u00e9signe un tableau dont chaque cellule pointe un tableau dont chaque cellule contient une valeur de type <code>double<\/code>.<\/p>\n<p>Les valeurs situ\u00e9e dans le tableau d\u00e9sign\u00e9 par <code>m<\/code> sont de type <code>double*<\/code>, donc m doit \u00eatre de type <code>double**<\/code>. Ce premier tableau doit \u00eatre r\u00e9serv\u00e9 par la ligne :<\/p>\n<pre><code class=\"language-C\">double** mat = (double**)malloc(DIM*sizeof(double*));\n<\/code><\/pre>\n<p>Chaque cellule de ce tableau d\u00e9signe une ligne du tableau 2D, qui est elle m\u00eame repr\u00e9sent\u00e9e par un tableau de <code>double<\/code>. Donc par exemple pour cr\u00e9er la premi\u00e8re ligne il faut \u00e9crire :<\/p>\n<pre><code class=\"language-C\">mat[0] = (double*)calloc(DIM, sizeof(double));\n<\/code><\/pre>\n<p>La cr\u00e9ation d&rsquo;un tableau de 3 x 3 n\u00e9cessite donc la r\u00e9servation de 4 blocs m\u00e9moire dans le tas. Il est judicieux de regrouper toutes les op\u00e9rations n\u00e9cessaires dans une fonction.<\/p>\n<pre><code class=\"language-C\">double** creeMatrice()\n{\n    double** mat = (double**)malloc(DIM*sizeof(double*));\n    for(int i=0; i&lt;DIM; i++)\n    {\n        mat[i] = (double*)calloc(DIM, sizeof(double));\n    }\n    return mat;\n}\n<\/code><\/pre>\n<p>La fonction <code>creeMatrice<\/code> r\u00e9alise la cr\u00e9ation d&rsquo;une matrice carr\u00e9e de dimension <code>DIM<\/code> dont les valeurs, de type <code>double<\/code>, sont initialis\u00e9es \u00e0 0.0.<\/p>\n<p>La valeur situ\u00e9e en ligne <code>i<\/code> et colonne <code>j<\/code> est dans la cellule <code>mat[i][j]<\/code>. En effet, <code>mat[i]<\/code> est un pointeur qui d\u00e9signe le tableau repr\u00e9sentant la ligne i, et en vertu de la correspondance entre tableaux et pointeurs, <code>mat[i][j]<\/code> est la cellule d&rsquo;indice <code>j<\/code> de cette ligne.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-e-dec-x9\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte E.dec.x9<\/h5>\n<p>D\u00e9finissez la fonction&#8230;<\/p>\n<pre><code class=\"language-C\">void afficheMatrice(double** mat);\n<\/code><\/pre>\n<p>&#8230;qui affiche la matrice d\u00e9sign\u00e9e par <code>mat<\/code>. Chaque valeur doit \u00eatre affich\u00e9e au format <code>%.02f<\/code>. Les valeurs de chaque ligne doivent \u00eatre s\u00e9par\u00e9es par des espaces.<\/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 afficheMatrice(double** mat)\n{\n    for(int i=0; i&lt;DIM; i++)\n    {\n        for(int j=0; j&lt;DIM; j++)\n        {\n            printf(\" %.02f\", mat[i][j]);\n        }\n        printf(\"\\n\");\n    }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<h5><a id=\"exercice-de-d%C3%A9couverte-e-dec-x10\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte E.dec.x10<\/h5>\n<p>R\u00e9alisez une fonction <code>main<\/code> qui cr\u00e9e une matrice en utilisant la fonction <code>creeMatrice<\/code> et qui l&rsquo;affiche en utilisant la fonction <code>afficheMatrice<\/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\">int main()\n{\n    double** m = creeMatrice();\n    afficheMatrice(m);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Pour lib\u00e9rer correctement la m\u00e9moire occup\u00e9e par une matrice, il faut lib\u00e9rer tous les blocs m\u00e9moires qui la constituent. Pour une matrice de 3 x 3, cela suppose 4 appels \u00e0 <code>free<\/code>. Pour faciliter cette t\u00e2che, il est judicieux de d\u00e9finir une fonction :<\/p>\n<pre><code class=\"language-C\">void detruitMatrice(double** m)\n{\n    for(int i=0; i&lt;DIM; i++)\n    {\n        free(m[i]);\n    }\n    free(m);\n}\n<\/code><\/pre>\n<h4><a id=\"bonus\" class=\"anchor\" aria-hidden=\"true\"><\/a>Bonus<\/h4>\n<table>\n<thead>\n<tr>\n<th>Simplifier les notation en d\u00e9finissant un type.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Les notations avec plusieurs \u00e9toiles peuvent para\u00eetre un peu lourdes. Il est possible de les all\u00e9ger en d\u00e9finissant de nouveaux type \u00e0 l&rsquo;aide de <code>typedef<\/code>. Par exemple, si on \u00e9crit&#8230;<\/p>\n<pre><code class=\"language-C\">typedef double** matrice;\n<\/code><\/pre>\n<p>&#8230;on d\u00e9finit un type <code>matrice<\/code> qui est \u00e9quivalent \u00e0 <code>double**<\/code>. Voici le code des fonctions de cr\u00e9ation, affichage et destruction de matrices utilisant ce type :<\/p>\n<pre><code class=\"language-C\">#define DIM 3\n\ntypedef double** matrice;\n\nmatrice creeMatrice()\n{\n    matrice mat = (matrice)malloc(DIM*sizeof(double*));\n    for(int i=0; i&lt;DIM; i++)\n    {\n        mat[i] = (double*)calloc(DIM, sizeof(double));\n    }\n    return mat;\n}\n\nvoid afficheMatrice(matrice mat)\n{\n    for(int i=0; i&lt;DIM; i++)\n    {\n        for(int j=0; j&lt;DIM; j++)\n        {\n            printf(\" %.02f\", mat[i][j]);\n        }\n        printf(\"\\n\");\n    }\n}\n\nvoid detruitMatrice(matrice m)\n{\n    for(int i=0; i&lt;DIM; i++)\n    {\n        free(m[i]);\n    }\n    free(m);\n}\n<\/code><\/pre>\n<h5><a id=\"exercice-de-d%C3%A9couverte-e-dec-x11\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte E.dec.x11<\/h5>\n<p>D\u00e9finissez une fonction <code>main<\/code> qui cr\u00e9e la matrice :<\/p>\n<p>\\[ \\begin{pmatrix}<br \/>\n1.0 &amp; 0.0 &amp; 0.0\\\\<br \/>\n0.0 &amp; 1.0 &amp; 0.0\\\\<br \/>\n0.0 &amp; 0.0 &amp; 1.0<br \/>\n\\end{pmatrix}<br \/>\n\\]<\/p>\n<p>Puis l&rsquo;affiche et la d\u00e9truit.<\/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 main()\n{\n    matrice m = creeMatrice();\n    m[0][0] = 1.0; m[1][1] = 1.0; m[2][2] = 1.0; \n    afficheMatrice(m);\n    detruitMatrice(m);\n    return 0;\n}\n<\/code><\/pre>\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-e-ent\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 d&rsquo;entra\u00eenement E.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-e-ent1\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration E.ent1<\/h3>\n<h4><a id=\"exercice-d-entrainement-e-ent1-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement E.ent1.1<\/h4>\n<p>D\u00e9finissez une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">char* randStr(const char* caracteres, int n);\n<\/code><\/pre>\n<p>&#8230;qui produit une cha\u00eene de <code>n<\/code> caract\u00e8res tir\u00e9s al\u00e9atoirement dans la cha\u00eene <code>caracteres<\/code>. La cha\u00eene produite doit \u00eatre situ\u00e9e dans le tas. Par exemple, la ligne&#8230;<\/p>\n<pre><code class=\"language-C\">char* s = randStr(\"abc\", 4);\n<\/code><\/pre>\n<p>&#8230;produit une cha\u00eene de 4 caract\u00e8res tir\u00e9s al\u00e9atoirement parmi les caract\u00e8res <code>a<\/code>, <code>b<\/code> et <code>c<\/code>. Une telle cha\u00eene pourrait par exemple \u00eatre <code>\"abba\"<\/code>, ou <code>\"cabc\"<\/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<pre><code class=\"language-C\">char* randStr(const char* caracteres, int n)\n{\n    char* out = (char*)malloc((n+1)*sizeof(char)); \/\/ Ligne A\n    int nchars = strlen(caracteres);               \/\/ Ligne B\n    \/\/ \u00c0 compl\u00e9ter\n    return out;                                    \/\/ Ligne C\n}\n<\/code><\/pre>\n<p>Voici le d\u00e9but du code de la fonction. <strong>La ligne A<\/strong> r\u00e9serve le bloc m\u00e9moire qui contiendra la cha\u00eene produite. Attention, la cha\u00eene doit contenir <code>n<\/code> caract\u00e8res plus un marqueur de fin. <strong>La ligne B<\/strong> d\u00e9termine la longueur de la cha\u00eene contenant les caract\u00e8res \u00e9ligibles pour \u00eatre plac\u00e9s dans le cha\u00eena \u00e0 produire. La ligne C retourne l&rsquo;adresse de la cha\u00eene produite apr\u00e8s qu&rsquo;elle ait \u00e9t\u00e9 remplie avec des caract\u00e8res tir\u00e9s al\u00e9atoirement dans la cha\u00eene <code>caracteres<\/code>, sans oublier le marqueur de fin.<\/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\">char* randStr(const char* caracteres, int n)\n{\n    char* out = (char*)malloc((n+1)*sizeof(char));\n    int nchars = strlen(caracteres);\n    for(int i=0; i&lt;n; i++)\n    {\n        out[i] = caracteres[rand()%nchars];\n    }\n    out[n] = 0;\n    return out;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez une fonction <code>main<\/code> qui cr\u00e9e (en utilisant <code>randStr<\/code>) une cha\u00eene al\u00e9atoire constitu\u00e9e de 6 lettre majuscules tir\u00e9es au hasard dans l&rsquo;alphabet, puis qui affiche cette cha\u00eene. La m\u00e9moire r\u00e9serv\u00e9e dans le tas doit \u00eatre lib\u00e9r\u00e9e apr\u00e8s utilisation.<\/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 main()\n{\n    srand(time(NULL));\n    char* s = randStr(\"ABCDEFGHIJKLMNOPQRSTUVWXYZ\", 6);\n    printf(\"%s\\n\", s);\n    free(s);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-e-ent1-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement E.ent1.2<\/h4>\n<p>Donnez les lignes de code permettant de r\u00e9aliser les actions suivantes :<\/p>\n<ol>\n<li>Cr\u00e9er dans la pile un tableau d&rsquo;entiers de taille 5 initialis\u00e9 avec les valeurs 1,2,3,4,5.<\/li>\n<li>Cr\u00e9er dans le tas un tableau d&rsquo;entiers de taille 5 non initialis\u00e9.<\/li>\n<li>Recopier les valeurs du premier tableau dans le deuxi\u00e8me.<\/li>\n<li>Placer la valeur 12 dans la cellule d&rsquo;indice 2 du deuxi\u00e8me tableau.<\/li>\n<li>Lib\u00e9rer la m\u00e9moire ayant \u00e9t\u00e9 r\u00e9serv\u00e9e dans le tas.<\/li>\n<\/ol>\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 t[] = {1,2,3,5,4};\n    int* w = (int*)malloc(5 * sizeof(int));\n    for(int i=0; i&lt;5; i++) w[i] = t[i];\n    w[2] = 12;\n    free(w);\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-e-ent1-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement E.ent1.3<\/h4>\n<blockquote><p>Cet exercice est un bon entra\u00eenement pour ce qui concerne les pointeurs, tableaux et gestion dynamique de la m\u00e9moire. Mais pour une impl\u00e9mentation plus professionnelle du concept, il est pr\u00e9f\u00e9rable d&rsquo;utiliser en plus la notion de structure, qui sera pr\u00e9sent\u00e9e dans la partie suivante. Il ne faut donc pas consid\u00e9rer l&rsquo;impl\u00e9mentation propos\u00e9e ici comme une solution d\u00e9finitive, mais comme une \u00e9tape d&rsquo;apprentissage.<\/p><\/blockquote>\n<p>On reprend le tableau 2D d\u00e9finit par le type <code>matrice<\/code> pr\u00e9sent\u00e9 pr\u00e9c\u00e9demment.<\/p>\n<pre><code class=\"language-C\">#define DIM 3\n\ntypedef double** matrice;\n\nmatrice creeMatrice()\n{\n    matrice mat = (matrice)malloc(DIM*sizeof(double*));\n    for(int i=0; i&lt;DIM; i++)\n    {\n        mat[i] = (double*)calloc(DIM, sizeof(double));\n    }\n    return mat;\n}\n\nvoid afficheMatrice(matrice mat)\n{\n    for(int i=0; i&lt;DIM; i++)\n    {\n        for(int j=0; j&lt;DIM; j++)\n        {\n            printf(\" %.02f\", mat[i][j]);\n        }\n        printf(\"\\n\");\n    }\n}\n\nvoid detruitMatrice(matrice m)\n{\n    for(int i=0; i&lt;DIM; i++)\n    {\n        free(m[i]);\n    }\n    free(m);\n}\n<\/code><\/pre>\n<p>Vous devez faire une premi\u00e8re modification pour repr\u00e9senter, avec un type que nous nommerons <code>tab2Ddouble<\/code>, des tableaux dont le nombre de lignes est d\u00e9finit par une constante <code>NLIGNES<\/code> et le nombre de colonnes par une constante <code>NCOLONNES<\/code>.<\/p>\n<pre><code class=\"language-C\">#define NLIGNES 2\n#define NCOLONNES 3\n\n\/\/ \u00c0 compl\u00e9ter\n\ntab2Ddouble creeTab2D()\n{\n    \/\/ \u00c0 compl\u00e9ter\n}\n\nvoid afficheTab2D(tab2Ddouble tab)\n{\n    \/\/ \u00c0 compl\u00e9ter\n}\n\nvoid detruitTab2D(tab2Ddouble tab)\n{\n    \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\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\">#define NLIGNES 2\n#define NCOLONNES 3\n\ntypedef double** tab2Ddouble;\n\ntab2Ddouble creeTab2D()\n{\n    tab2Ddouble tab = (tab2Ddouble)malloc(NLIGNES*sizeof(double*));\n    for(int i=0; i&lt;NLIGNES; i++)\n    {\n        tab[i] = (double*)calloc(NCOLONNES, sizeof(double));\n    }\n    return tab;\n}\n\nvoid afficheTab2D(tab2Ddouble tab)\n{\n    for(int i=0; i&lt;NLIGNES; i++)\n    {\n        for(int j=0; j&lt;NCOLONNES; j++)\n        {\n            printf(\" %.02f\", tab[i][j]);\n        }\n        printf(\"\\n\");\n    }\n}\n\nvoid detruitTab2D(tab2Ddouble tab)\n{\n    for(int i=0; i&lt;NLIGNES; i++)\n    {\n        free(tab[i]);\n    }\n    free(tab);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Une personne d\u00e9butante en programmation C \u00e9crit la fonction suivante ayant pour r\u00f4le d&rsquo;\u00e9changer les contenus de deux tableaux.<\/p>\n<pre><code class=\"language-C\">void exgTab2D(tab2Ddouble t1, tab2Ddouble t2)\n{\n    tab2Ddouble tmp = t1;\n    t1 = t2;\n    t2 = tmp;\n}\n<\/code><\/pre>\n<p>Mais la fonction ne remplit pas son r\u00f4le. Si on ex\u00e9cute le programme suivant :<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    tab2Ddouble tab1 = creeTab2D();\n    tab2Ddouble tab2 = creeTab2D();\n    tab1[0][0] = 3.0;\n    tab2[1][2] = 9.0;\n    \n    printf(\"Avant :\\n\");\n    afficheTab2D(tab1);\n    printf(\"\\n\");\n    afficheTab2D(tab2);\n    \n    exgTab2D(tab1, tab2);\n    \n    printf(\"\\nApr\u00e8s :\\n\");\n    afficheTab2D(tab1);\n    printf(\"\\n\");\n    afficheTab2D(tab2);\n\n    return 0;\n}\n<\/code><\/pre>\n<p>On obtient exactement le m\u00eame affichage avant et apr\u00e8s appel de la fonction. Les tableaux d\u00e9sign\u00e9s par <code>tab1<\/code> et <code>tab2<\/code> n&rsquo;ont pas \u00e9t\u00e9 \u00e9chang\u00e9s. Vous devez menez une enqu\u00eate afin de trouver une explication du ph\u00e9nom\u00e8ne.<\/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>Quand on appelle <code>exTab2D(tab1, tab2)<\/code>, les valeurs de <code>tab1<\/code> et <code>tab2<\/code>, c&rsquo;est \u00e0 dire les adresses des 2 tableaux, sont <strong>copi\u00e9es<\/strong> dans les param\u00e8tres <code>t1<\/code> et <code>t2<\/code> de la fonction. Ce sont ce copies que le fonction \u00e9change, ce qui n&rsquo;affecte pas les contenus des variables <code>tab1<\/code> et <code>tab2<\/code>.<\/p>\n<p>Voici la situation en m\u00e9moire au d\u00e9but de l&rsquo;ex\u00e9cution de la fonction <code>exTab2D<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/9-4.png\" alt=\"image-20220121203338900\" \/><\/p>\n<p>Et voici la situation en m\u00e9moire \u00e0 la fin de l&rsquo;ex\u00e9cution de cette fonction.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/10-4.png\" alt=\"image-20220121203533280\" \/><\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Vous devez trouver un moyen de coder cette fonction de mani\u00e8re \u00e0 ce que les contenus des tableaux soient effectivement \u00e9chang\u00e9s.<\/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 pourrait \u00e9changer chaque valeur du premier tableau avec la valeur situ\u00e9e en m\u00eame position dans le deuxi\u00e8me, mais une solution plus rapide est d&rsquo;\u00e9changer le pointeur sur chaque ligne d&rsquo;un des tableau avec le pointeur sur la ligne ayant la m\u00eame position dans l&rsquo;autre.<\/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 exgTab2D(tab2Ddouble t1, tab2Ddouble t2)\n{\n    for(int i=0; i&lt;NLIGNES; i++)\n    {\n        double* tmp = t1[i];\n        t1[i] = t2[i];\n        t2[i] = tmp;\n    }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez une variante qui accepte en param\u00e8tres les <strong>adresses<\/strong> des variables d\u00e9signant les tableaux \u00e0 \u00e9changer :<\/p>\n<pre><code class=\"language-C\">void exgTab2D(tab2Ddouble* t1, tab2Ddouble* t2);\n<\/code><\/pre>\n<p>Donnez la modification \u00e0 faire dans la fonction <code>main<\/code> pr\u00e9c\u00e9dente pour appeler correctement la nouvelle fonction d&rsquo;\u00e9change.<\/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 exgTab2D(tab2Ddouble* t1, tab2Ddouble* t2)\n{\n    tab2Ddouble tmp = *t1;\n    *t1 = *t2;\n    *t2 = tmp;\n}\n<\/code><\/pre>\n<p>Ce sont les valeurs point\u00e9es par t1 et t2 qu&rsquo;il faut \u00e9changer, et on acc\u00e8de \u00e0 ces valeurs par l&rsquo;op\u00e9rateur de \u00ab\u00a0d\u00e9pointage\u00a0\u00bb <code>*<\/code>.<\/p>\n<p>Dans la fonction <code>main<\/code>, il faut remplacer la ligne&#8230;<\/p>\n<pre><code class=\"language-C\">exgTab2D(tab1, tab2);\n<\/code><\/pre>\n<p>&#8230;par la ligne :<\/p>\n<pre><code class=\"language-C\">exgTab2D(&amp;tab1, &amp;tab2);\n<\/code><\/pre>\n<p>En effet, ce sont les adresses des variables <code>tab1<\/code> et <code>tab2<\/code> qui doivent \u00eatre pass\u00e9es en arguments.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Dessinez la situation en m\u00e9moire au d\u00e9but et \u00e0 la fin de l&rsquo;ex\u00e9cution de cette nouvelle variante de la fonction appel\u00e9e par <code>main<\/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<p>Au d\u00e9but de l&rsquo;ex\u00e9cution :<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/11-4.png\" alt=\"image-20220121210831100\" \/><\/p>\n<p>\u00c0 la fin de l&rsquo;ex\u00e9cution :<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/12-3.png\" alt=\"image-20220121210937741\" \/><\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"it%C3%A9ration-e-ent2\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration E.ent2<\/h3>\n<h4><a id=\"exercice-d-entrainement-e-ent2-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement E.ent2.1<\/h4>\n<p>D\u00e9finissez une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">char* cloneStr(const char* s);\n<\/code><\/pre>\n<p>&#8230;qui produit une cha\u00eene situ\u00e9e dans le tas, strictement identique \u00e0 la cha\u00eene d\u00e9sign\u00e9e par <code>s<\/code>, mais compl\u00e8tement ind\u00e9pendante en m\u00e9moire (une modification de la cha\u00eene produite ne doit pas affecter la cha\u00eene ayant servi de mod\u00e8le, et r\u00e9ciproquement).<\/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\">char* cloneStr(const char* s)\n{\n    int n = strlen(s);\n    char* out = (char*)malloc((n+1)*sizeof(char));\n    \/\/ \u00c0 compl\u00e9ter\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\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">char* cloneStr(const char* s)\n{\n    int n = strlen(s);\n    char* out = (char*)malloc((n+1)*sizeof(char));\n    strcpy(out, s);\n    return out;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez une fonction <code>main<\/code> qui cr\u00e9e (en utilisant <code>cloneStr<\/code>) une copie de la cha\u00eene <code>\"Bonjour\"<\/code>, puis qui affiche cette cha\u00eene. La m\u00e9moire r\u00e9serv\u00e9e dans le tas doit \u00eatre lib\u00e9r\u00e9e apr\u00e8s utilisation.<\/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 main()\n{\n    char* s = cloneStr(\"Bonjour\");\n    printf(\"%s\\n\", s);\n    free(s);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-e-ent2-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement E.ent2.2<\/h4>\n<p>Donnez les lignes de code permettant de r\u00e9aliser les actions suivantes :<\/p>\n<ol>\n<li>Cr\u00e9er dans le tas un tableau d&rsquo;entiers de taille 5 dont les 4 premi\u00e8res cellules contiennent la valeur 0 et la derni\u00e8re cellule contient la valeur 2.<\/li>\n<li>Cr\u00e9er dans la pile tableau d&rsquo;entiers de taille 5 non initialis\u00e9.<\/li>\n<li>Recopier les valeurs du premier tableau dans le deuxi\u00e8me.<\/li>\n<li>Lib\u00e9rer la m\u00e9moire ayant \u00e9t\u00e9 r\u00e9serv\u00e9e dans le tas.<\/li>\n<\/ol>\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* t = (int*)calloc(5, sizeof(int));\n    t[4] = 2;\n    int w[5];\n    for(int i=0; i&lt;5; i++) w[i] = t[i];\n    free(t);\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-e-ent2-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement E.ent2.3<\/h4>\n<blockquote><p>Cet exercice est un bon entra\u00eenement pour ce qui concerne les pointeurs, tableaux et gestion dynamique de la m\u00e9moire. Mais pour une impl\u00e9mentation plus professionnelle du concept, il est pr\u00e9f\u00e9rable d&rsquo;utiliser en plus la notion de structure, qui sera pr\u00e9sent\u00e9e dans la partie suivante. Il ne faut donc pas consid\u00e9rer l&rsquo;impl\u00e9mentation propos\u00e9e ici comme une solution d\u00e9finitive, mais comme une \u00e9tape d&rsquo;apprentissage.<\/p><\/blockquote>\n<p>On d\u00e9finit la constante et le type suivants :<\/p>\n<pre><code class=\"language-C\">#define SIZE 3\ntypedef char** tabstr;\n<\/code><\/pre>\n<p>Le type <code>tabstr<\/code> repr\u00e9sente un tableau de cha\u00eenes de caract\u00e8res de taille <code>SIZE<\/code> dont certaines cellules peuvent \u00eatre vides. Une cellule vide contient la valeur <code>NULL<\/code>, alors qu&rsquo;une cellule non vide contient un pointeur sur <code>char<\/code> d\u00e9signant une cha\u00eene stock\u00e9e dans le tas.<\/p>\n<p>Les fonctions suivantes permettent l&rsquo;utilisation de tableaux de cha\u00eene de type <code>tabstr<\/code>.<\/p>\n<pre><code class=\"language-C\">\/\/ Cr\u00e9e un tableau de SIZE cellules vides.\ntabstr creeTabstr();\n\n\/\/ Place une copie de la cha\u00eene d\u00e9sign\u00e9e par str dans la cellule i\n\/\/ du tableau d\u00e9sign\u00e9 par tab.\nvoid assigne(tabstr tab, int i, char* str);\n\n\/\/ Affiche le contenu du tableau d\u00e9sign\u00e9 par tab.\n\/\/ Les cellules vides sont repr\u00e9sent\u00e9es par ---\nvoid affiche(tabstr tab);\n\n\/\/ Lib\u00e8re toute la m\u00e9moire occup\u00e9e par le tableau d\u00e9sign\u00e9 par tab.\nvoid detruit(tabstr tab);\n<\/code><\/pre>\n<p>Voici un exemple de mise en oeuvre de ces fonctions :<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    tabstr t = creeTabstr();\n    assigne(t,0,\"Tim\");\n    assigne(t,1,\"Tom\");\n    assigne(t,0,\"Anne\");\n    affiche(t);\n    detruit(t);\n    return 0;\n}\n<\/code><\/pre>\n<p>L&rsquo;ex\u00e9cution de <code>main<\/code> produit l&rsquo;affichage :<\/p>\n<pre><code class=\"language-plain_text\">Anne\nTom\n---\n<\/code><\/pre>\n<hr \/>\n<p>Dessinez la situation en m\u00e9moire juste apr\u00e8s l&rsquo;ex\u00e9cution de la fonction <code>affiche<\/code> appel\u00e9 par <code>main<\/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<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/13-3.png\" alt=\"image-20220121220149284\" \/><\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Donnez les d\u00e9finitions des fonctions suivantes :<\/p>\n<ol>\n<li><code>creeTabstr<\/code><\/li>\n<li><code>affiche<\/code><\/li>\n<li><code>assigne<\/code><\/li>\n<li><code>detruit<\/code><\/li>\n<\/ol>\n<p>Vous devez pr\u00eater une attention particuli\u00e8re \u00e0 \u00e9viter les fuites et accidents m\u00e9moire. Lorsqu&rsquo;on cr\u00e9e un tableau dynamique de pointeurs avec <code>calloc<\/code>, ces cellules contiennent toutes la valeur <code>NULL<\/code>, qui est repr\u00e9sent\u00e9e en m\u00e9moire par des octets ayant la valeur 0.<\/p>\n<p>Pour coder correctement les fonctions <code>affiche<\/code>, <code>assigne<\/code> et <code>detruit<\/code>, il faut bien distinguer le cas d&rsquo;une cellule contenant <code>NULL<\/code> d&rsquo;une cellule pointant une cha\u00eene pr\u00e9alablement assign\u00e9e.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">tabstr creeTabstr()\n{\n    tabstr out = (tabstr)calloc(SIZE, sizeof(char*));\n    return out;\n}\n<\/code><\/pre>\n<p>On r\u00e9serve un bloc m\u00e9moire qui sera utilis\u00e9 comme tableau de <code>SIZE<\/code> pointeurs de type <code>char*<\/code>. La fonction <code>calloc<\/code> initialise le bloc avec des 0, donc les cellules du tableau contiennent <code>NULL<\/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\">R\u00e9ponse2<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">void affiche(tabstr tab)\n{\n    for(int i=0; i&lt;SIZE; i++)\n    {\n        if(tab[i]==NULL) printf(\"---\\n\");\n        else printf(\"%s\\n\", tab[i]);\n    }\n}\n<\/code><\/pre>\n<p>Il ne faut pas utiliser <code>printf<\/code> avec le format <code>%s<\/code> dans le cas o\u00f9 la cellule contient <code>NULL<\/code>, mais faire un affichage sp\u00e9cifique dans ce cas.<\/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\u00e9ponse3<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">void assigne(tabstr tab, int i, char* str)\n{\n    if(tab[i] != NULL) free(tab[i]);\n    int n = strlen(str);\n    tab[i] = (char*)malloc((n+1)*sizeof(char));\n    strcpy(tab[i], str);\n}\n<\/code><\/pre>\n<p>Il faut penser \u00e0 beaucoup de choses pour coder correctement cette fonction :<\/p>\n<ul>\n<li>Si la cellule \u00e0 assigner pointe d\u00e9j\u00e0 une cha\u00eene, c&rsquo;est \u00e0 dire si elle a d\u00e9j\u00e0 \u00e9t\u00e9 pr\u00e9alablement assign\u00e9e, il faut lib\u00e9rer la m\u00e9moire occup\u00e9e par la cha\u00eene pr\u00e9c\u00e9dente, sinon on aura une fuite m\u00e9moire.<\/li>\n<li>Il faut r\u00e9server un bloc m\u00e9moire pour y placer la <strong>copie<\/strong> de la cha\u00eene \u00e0 assigner \u00e0 la cellule d&rsquo;indice i.<\/li>\n<li>La taille du bloc \u00e0 r\u00e9server doit pr\u00e9voir d&rsquo;y placer la copie de la cha\u00eene \u00e0 assigner sans oublier le marqueur de fin.<\/li>\n<li>La copie de la cha\u00eene \u00e0 assigner dans le bloc destin\u00e9 \u00e0 la contenir doit \u00eatre r\u00e9alis\u00e9e par un appel \u00e0 la fonction <code>strcpy<\/code> et en aucun cas avec <code>=<\/code>.<\/li>\n<\/ul>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse4<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">void detruit(tabstr tab)\n{\n    for(int i=0; i&lt;SIZE; i++)\n    {\n        if(tab[i] != NULL) free(tab[i]);\n    }\n    free(tab);\n}\n<\/code><\/pre>\n<p>Il faut lib\u00e9rer la m\u00e9moire utilis\u00e9e pour stocker les cha\u00eenes, mais il peut y avoir des cellules vides (contenant <code>NULL<\/code>), qui ne pointent donc aucune cha\u00eene. Il ne faut jamais appeler free avec <code>NULL<\/code> en argument, cela provoque un accident m\u00e9moire.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"it%C3%A9ration-e-ent3\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration E.ent3<\/h3>\n<h4><a id=\"exercice-d-entrainement-e-ent3-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement E.ent3.1<\/h4>\n<p>D\u00e9finissez une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">char* addChar(const char* s, char c);\n<\/code><\/pre>\n<p>&#8230;qui produit une obtenue en ajoutant le caract\u00e8re <code>c<\/code> a une copie de la cha\u00eene d\u00e9sign\u00e9e par <code>s<\/code>. Par exemple, l&rsquo;appel <code>addChar(\"Tim\", 'e')<\/code> retourne l&rsquo;adresse d&rsquo;une cha\u00eene <code>\"Time\"<\/code> situ\u00e9e dans le tas.<\/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\">char* addChar(const char* s, char c)\n{\n    int n = strlen(s);\n    char* out = (char*)malloc((n+2)*sizeof(char));\n    \/\/ \u00c0 compl\u00e9ter\n    return out;\n}\n<\/code><\/pre>\n<p>La partie de la fonction donn\u00e9e ici r\u00e9serve le bloc m\u00e9moire dans lequel sera plac\u00e9 la cha\u00eene \u00e0 produire. Il faut pr\u00e9voir la place pour placer le caract\u00e8re \u00e0 ajouter et le marqueur de fin. Il reste \u00e0 terminer la construction.<\/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\">char* addChar(const char* s, char c)\n{\n    int n = strlen(s);\n    char* out = (char*)malloc((n+2)*sizeof(char));\n    strcpy(out, s);\n    out[n] = c;\n    out[n+1] = 0;\n    return out;\n}\n<\/code><\/pre>\n<p>Remarque : la fonction <code>strcat<\/code> n&rsquo;est pas utilisable pour concat\u00e9ner un caract\u00e8re \u00e0 une cha\u00eene. Le caract\u00e8re est ajout\u00e9 directement dans le tableau repr\u00e9sentant la cha\u00eene, \u00e0 l&#8217;emplacement appropri\u00e9.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-e-ent3-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement E.ent3.2<\/h4>\n<p>Donnez les lignes de code permettant de r\u00e9aliser les actions suivantes :<\/p>\n<ol>\n<li>Cr\u00e9er dans la pile une cha\u00eene initialis\u00e9e avec \u00ab\u00a0abcde\u00a0\u00bb.<\/li>\n<li>Cr\u00e9er dans le tas un tableau de 6 caract\u00e8res.<\/li>\n<li>Recopier dans ce tableau la cha\u00eene cr\u00e9\u00e9e \u00e0 l&rsquo;\u00e9tape 1.<\/li>\n<li>Lib\u00e9rer la m\u00e9moire ayant \u00e9t\u00e9 r\u00e9serv\u00e9e dans le tas.<\/li>\n<\/ol>\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\">    char t[] = \"abcde\";\n    char* s = malloc(6 * sizeof(char));\n    strcpy(s, t);\n    free(t);\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<h2><a id=\"activit%C3%A9-de-consolidation-e-top\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 de consolidation E.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>On appelle <strong>tableau inform\u00e9<\/strong> de taille n un tableau d&rsquo;entiers dont les valeurs sont stock\u00e9es aux indices 1 \u00e0 n et la longueur est stock\u00e9e \u00e0 l&rsquo;indice 0. Un tel tableau est donc repr\u00e9sent\u00e9 par un tableau de n+1 cellules de type <code>int<\/code>. Voici un exemple de tableau de valeur de type <code>int<\/code> repr\u00e9sentant le tableau inform\u00e9 de taille 4 contenant les valeurs 2, 3, 5, 7 :<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/6-6.png\" alt=\"image-20220120213734096\" \/><\/p>\n<p>On d\u00e9finit le type <code>tabinf<\/code> pour repr\u00e9senter les tableaux inform\u00e9s :<\/p>\n<pre><code class=\"language-C\">typedef int* tabinf;\n<\/code><\/pre>\n<p>Pour rappel, cette notation signifie que l&rsquo;identificateur <code>tabinf<\/code> est \u00e9quivalent \u00e0 <code>int*<\/code>. En effet, un tableau inform\u00e9 est repr\u00e9sent\u00e9 par un tableau de valeurs de type <code>int<\/code>, qui est d\u00e9sign\u00e9, en vertu de la correspondance entre pointeurs et tableaux, par un pointeur sur <code>int<\/code>.<\/p>\n<p>Votre premi\u00e8re mission consiste \u00e0 d\u00e9finir une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">tabinf creeTabinf(int n);\n<\/code><\/pre>\n<p>&#8230;qui cr\u00e9e un tableau inform\u00e9 situ\u00e9 dans le tas contenant <code>n<\/code> valeurs 0.<\/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\">tabinf creeTabinf(int n)\n{\n tabinf out = calloc(n+1, sizeof(int));  \/\/ Ligne A\n out[0] = n;                             \/\/ Ligne B\n return out;                             \/\/ Ligne C\n}\n<\/code><\/pre>\n<p><strong>En ligne A<\/strong>, un bloc m\u00e9moire permettant de stocker n+1 entiers est r\u00e9serv\u00e9. Ce bloc est initialis\u00e9 avec des valeurs 0 et est utilisable comme un tableau classique de valeurs de type <code>int<\/code>.<\/p>\n<p><strong>En ligne B<\/strong>, la valeur <code>n<\/code> est plac\u00e9e dans la premi\u00e8re cellule du tableau venant d&rsquo;\u00eatre cr\u00e9\u00e9, puisque ce tableau repr\u00e9sente un tableau inform\u00e9 de taille <code>n<\/code>.<\/p>\n<p><strong>La ligne C<\/strong> retourne l&rsquo;adresse du tableau inform\u00e9 cr\u00e9\u00e9.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Vous devez maintenant d\u00e9finir une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">void printTabinf(tabinf t)\n<\/code><\/pre>\n<p>&#8230;qui affiche les valeurs d&rsquo;un tableau inform\u00e9 (pas sa taille) s\u00e9par\u00e9es par des espaces.<\/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 printTabinf(tabinf t)\n{\n for(int i=1; i&lt;=t[0]; i++)\n {\n     printf(\" %d\", t[i]);\n }\n printf(\"\\n\");\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez une fonction <code>main<\/code> qui<\/p>\n<ul>\n<li>Cr\u00e9e un tableau inform\u00e9 de taille 10 contenant des valeurs 0 sauf \u00e0 l&rsquo;indice 2 o\u00f9 il y a la valeur 12.<\/li>\n<li>Affiche ce tableau inform\u00e9 avec la fonction <code>printTabinf<\/code>.<\/li>\n<li>Lib\u00e8re la m\u00e9moire utilis\u00e9e par le tableau.<\/li>\n<\/ul>\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 main()\n{\n tabinf tab = creeTabinf(10);\n tab[2] = 12;\n printTabinf(tab);\n free(tab);\n return 0;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Nous attaquons \u00e0 pr\u00e9sent la partie plus technique de l&rsquo;exercice. Vous devez d\u00e9finir une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">void agrandit(tabinf* t, int delta);\n<\/code><\/pre>\n<p>&#8230;qui agrandit un tableau inform\u00e9 en lui ajoutant delta valeurs suppl\u00e9mentaires, toutes initialis\u00e9es \u00e0 0. Vous ne devez pas utiliser (dans cette premi\u00e8re version), la fonction <code>realloc<\/code>. Donc vous devez cr\u00e9er un nouveau tableau plus grand et recopier dedans les valeur de l&rsquo;ancien, sans oublier de d\u00e9truire l&rsquo;ancien ensuite, afin d&rsquo;\u00e9viter toute fuite m\u00e9moire.<\/p>\n<p>Il est <strong>tr\u00e8s important<\/strong> de bien comprendre pourquoi le premier param\u00e8tre est de type <code>tabinf*<\/code>, c&rsquo;est \u00e0 dire <code>int**<\/code>, et ce que cela implique, \u00e0 savoir que lors de l&rsquo;appel de la fonction, il faut lui passer en premier argument l&rsquo;adresse d&rsquo;une variable de type <code>tabinf<\/code>.<\/p>\n<p>Voici un exemple de cr\u00e9ation, puis d&rsquo;agrandissement d&rsquo;un tableau inform\u00e9.<\/p>\n<pre><code class=\"language-C\">int main()\n{\n tabinf tab = creeTabinf(10);\n tab[2] = 12;\n printTabinf(tab);\n agrandit(&amp;tab, 5);\n printTabinf(tab);\n free(tab);\n return 0;\n}\n<\/code><\/pre>\n<p>Vous devez r\u00e9fl\u00e9chir et r\u00e9pondre \u00e0 la question suivante : <strong>Pourquoi<\/strong> une fonction <code>agrandit<\/code> avec une param\u00e8tre de type <code>tabinf<\/code> (c&rsquo;est \u00e0 dire <code>int*<\/code>) ne pourrait pas permettre de r\u00e9aliser correctement le travail demand\u00e9, \u00e0 savoir remplacer le tableau inform\u00e9 initialement cr\u00e9\u00e9 par une plus grand contenant les valeurs du premier et des 0 suppl\u00e9mentaires ?<\/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;agrandissement d&rsquo;un tableau inform\u00e9 change son adresse m\u00e9moire, qui est contenue dans la variable <code>tab<\/code>. Si on passe cette adresse en argument \u00e0 la fonction d&rsquo;agrandissement, c&rsquo;est une <strong>copie<\/strong> de cette adresse qui sera transmise \u00e0 la fonction. Lors de son ex\u00e9cution, la fonction <code>agrandit<\/code> va modifier cette <strong>copie<\/strong> d&rsquo;adresse, mais cela ne modifiera pas contenu de la variable <code>tab<\/code> qui continuera de pointer sur l&rsquo;ancien tableau ou sur son fant\u00f4me si la m\u00e9moire qu&rsquo;il occupait a \u00e9t\u00e9 lib\u00e9r\u00e9e.<\/p>\n<p>Voici une illustration en image du \u00ab\u00a0sc\u00e9nario catastrophe\u00a0\u00bb.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/7-5.png\" alt=\"image-20220120231118463\" \/><\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Si vous avez bien compris pourquoi c&rsquo;est l&rsquo;adresse d&rsquo;une variable pointant le tableau inform\u00e9 \u00e0 agrandir qu&rsquo;il faut passer en param\u00e8tre \u00e0 la fonction <code>agrandit<\/code>, et non directement l&rsquo;adresse du tableau, alors vous pouvez continuer l&rsquo;exercice en proposant une d\u00e9finition de la fonction demand\u00e9e. Prenez le temps de bien r\u00e9fl\u00e9chir \u00e0 toutes les \u00e9tapes n\u00e9cessaires.<\/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<pre><code class=\"language-C\">void agrandit(tabinf* t, int delta)\n{\n tabinf tab = *t;   \/\/ Ligne A\n int n = tab[0];    \/\/ Ligne B\n \/\/ \u00c0 compl\u00e9ter\n *t = newtab;       \/\/ Ligne C\n}\n<\/code><\/pre>\n<p><strong>En ligne A<\/strong>, l&rsquo;adresse d&rsquo;implantation du tableau \u00e0 agrandir, que nous appellerons ancien tableau, est r\u00e9cup\u00e9r\u00e9e et plac\u00e9e dans la variable <code>tab<\/code>.<\/p>\n<p><strong>En ligne B<\/strong>, on place dans la variable <code>n<\/code> la taille de l&rsquo;ancien tableau.<\/p>\n<p><strong>En ligne C<\/strong>, on place dans la variable point\u00e9e par <code>t<\/code>, c&rsquo;est \u00e0 dire la variable qui pointe initialement l&rsquo;ancien tableau, l&rsquo;adresse du nouveau tableau.<\/p>\n<p>Voici la situation en m\u00e9moire apr\u00e8s l&rsquo;ex\u00e9cution de la ligne B, en supposant que la variable <code>m<\/code>, dans la fonction <code>main<\/code>, d\u00e9signe le tableau \u00e0 agrandir et que ce tableau, de taille 4, contient les valeurs 2, 3, 5 et 7.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/8-5.png\" alt=\"image-20220120231807827\" \/><\/p>\n<p>Entre les ligne B et C, il faut :<\/p>\n<ul>\n<li>Cr\u00e9er le nouveau tableau en utilisant <code>calloc<\/code>.<\/li>\n<li>Recopier les <code>n<\/code> valeurs de l&rsquo;ancien tableau dans le nouveau.<\/li>\n<li>Placer la valeur appropri\u00e9e dans la premi\u00e8re cellule du nouveau tableau.<\/li>\n<li>D\u00e9truire l&rsquo;ancien tableau.<\/li>\n<\/ul>\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 agrandit(tabinf* t, int delta)\n{\n tabinf tab = *t;\n int n = tab[0];\n tabinf newtab = (tabinf)calloc(n+delta+1, sizeof(int));\n for(int i=1; i&lt;=n; i++) newtab[i] = tab[i];\n newtab[0] = n+delta;\n free(tab);\n *t = newtab;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Proposez maintenant une variante de la fonction <code>agrandit<\/code> utilisant <code>realloc<\/code> au lieu de <code>calloc<\/code>. Attention, <code>realloc<\/code>, dans le cas d&rsquo;un agrandissement, recopie les valeurs de l&rsquo;ancien tableau dans le nouveau, mais n&rsquo;initialise pas les valeurs suivantes du nouveau tableau.<\/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 agrandit(tabinf* t, int delta)\n{\n tabinf tab = *t;\n int n = tab[0];\n tab = (tabinf)realloc(tab, (n+delta+1)*sizeof(int));\n for(int i=n+1; i&lt;=n+delta; i++) tab[i] = 0;\n tab[0] = n+delta;\n *t = tab;\n}\n<\/code><\/pre>\n<p>Des variantes sont possibles. Chaque d\u00e9tail est important. Il est possible qu&rsquo;une fonction se comporte apparemment correctement lors d&rsquo;un test mais comporte n\u00e9anmoins une erreur pouvant occasionner par exemple une fuite m\u00e9moire, ou placer des valeurs inopin\u00e9es dans certaines cellules du nouveau tableau, mais pas \u00e0 chaque fois. Un regard d&rsquo;expert est n\u00e9cessaire pour valider votre solution si elle est diff\u00e9rente de celle-ci.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n","protected":false},"excerpt":{"rendered":"<p>Par O. Bailleux, Ma\u00eetre de conf\u00e9rences HDR \u00e0 l&rsquo;universit\u00e9 de Bourgogne. Tableaux dynamiques 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 la [&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-151","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\/151","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=151"}],"version-history":[{"count":3,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/151\/revisions"}],"predecessor-version":[{"id":244,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/151\/revisions\/244"}],"wp:attachment":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/media?parent=151"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/categories?post=151"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/tags?post=151"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}