{"id":238,"date":"2022-02-11T20:42:51","date_gmt":"2022-02-11T20:42:51","guid":{"rendered":"https:\/\/9h15.net\/activ\/?p=238"},"modified":"2022-03-12T14:20:35","modified_gmt":"2022-03-12T14:20:35","slug":"c-et-c-partie-f","status":"publish","type":"post","link":"https:\/\/9h15.net\/activ\/c-et-c-partie-f\/","title":{"rendered":"C et C++ partie F"},"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=\"structures\" class=\"anchor\" aria-hidden=\"true\"><\/a>Structures<\/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-f-dec\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 de d\u00e9couverte F.dec<\/h2>\n<h3><a id=\"f-dec1-notion-de-structure\" class=\"anchor\" aria-hidden=\"true\"><\/a>F.dec1 : Notion de structure<\/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<\/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>Regrouper plusieurs donn\u00e9es, possiblement de type diff\u00e9rents, dans une m\u00eame capsule<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Dans les parties pr\u00e9c\u00e9dentes le seul moyen de rassembler plusieurs valeurs \u00e9tait de les placer dans un tableau. Mais cette solution n&rsquo;est applicable que si les donn\u00e9es \u00e0 agr\u00e9ger sont de m\u00eame type. Quand nous voulions repr\u00e9senter une donn\u00e9e complexe regroupant des informations de types diff\u00e9rents, nous \u00e9tions contraint de placer ces informations dans plusieurs variables, et quand on devait les transmettre \u00e0 des fonction nous utilisions plusieurs param\u00e8tres.<\/p>\n<p>Pour simplifier les programmes, il est pratique de pouvoir regrouper plusieurs informations dans une m\u00eame \u00ab\u00a0capsule\u00a0\u00bb. La notion de <strong>structure<\/strong> r\u00e9pond \u00e0 ce besoin.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Les structures<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Une <strong>structure<\/strong> est un type de donn\u00e9e permettant de d\u00e9crire des <strong>instances de structures<\/strong>. Une instance de structure regroupe une ou plusieurs informations identifi\u00e9es par des noms appel\u00e9 <strong>champs<\/strong>.<\/p>\n<p>Voici un premier exemple d&rsquo;une structure permettant de repr\u00e9senter des points dans un espace \u00e0 deux dimensions.<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    double x;\n    double y;\n}point;\n<\/code><\/pre>\n<p>Cette d\u00e9claration cr\u00e9e le un type nomm\u00e9 <code>point<\/code>. Les donn\u00e9es de ce type sont constitu\u00e9es de deux champs nomm\u00e9s <code>x<\/code> et <code>y<\/code> qui contiennent des valeurs de type <code>double<\/code>. Les champs d&rsquo;une structure peuvent avoir n&rsquo;importe quel type, y compris un type structure ou tableau, et ne sont pas tous n\u00e9cessairement tous du m\u00eame type.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x1<\/h5>\n<p>D\u00e9finissez une structure <code>date<\/code> permettant de repr\u00e9senter une date constitu\u00e9e d&rsquo;un jour de la semaine repr\u00e9sent\u00e9 par un entier de type <code>char<\/code>, un num\u00e9ro de mois repr\u00e9sent\u00e9 de la m\u00eame mani\u00e8re, et une ann\u00e9e, repr\u00e9sent\u00e9e par une valeur de type <code>int<\/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\">typedef struct\n{\n    char jour;\n    char mois;\n    int annee;\n}date;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>On peut d\u00e9clarer des variables de type structure, les initialiser avec une syntaxe similaire \u00e0 celle permettant d&rsquo;initialiser des tableaux, et on peut acc\u00e9der au valeurs des champs d&rsquo;une instance de structure en utilisant la syntaxe pr\u00e9sent\u00e9e dans cet exemple.<\/p>\n<pre><code class=\"language-C\">void test(void)\n{\n    point p1 = {1.0, 2.0};                 \/\/ Ligne A\n    printf(\"(%.02f,%.02f)\\n\", p1.x, p1.y); \/\/ Ligne B\n}\n<\/code><\/pre>\n<p><strong>En ligne A<\/strong> une variable de type <code>point<\/code> est d\u00e9clar\u00e9e et initialis\u00e9e. Ce type d&rsquo;initialisation n&rsquo;est possible que lors de la d\u00e9claration d&rsquo;une variable de type structure. Par la suite, on ne peut pas utiliser cette syntaxe pour modifier le contenu d&rsquo;une variable de type structure. La variable <code>point<\/code> est implant\u00e9e en m\u00e9moire dans la pile.<\/p>\n<p><strong>En ligne B<\/strong>, Les valeurs des deux champs de l&rsquo;instance de structure situ\u00e9e dans la variable <code>p1<\/code> sont affich\u00e9es. La notation <code>p1.x<\/code> d\u00e9signe le champs x de l&rsquo;instance de structure contenue dans la variable <code>p1<\/code>. Cette syntaxe se g\u00e9n\u00e9ralise \u00e0 n&rsquo;importe quel champ d&rsquo;une structure.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x2<\/h5>\n<p>Donnez les lignes de code permettant de d\u00e9clarer une variable de type <code>date<\/code> <strong>non initialis\u00e9e<\/strong>, puis d&rsquo;assigner la valeur 1 au champ <code>jour<\/code>, la valeur 3 au champ <code>mois<\/code> et la valeur 1905 au champ <code>annee<\/code> de l&rsquo;instance de structure situ\u00e9e dans cette variable.<\/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\">    date d;\n    d.jour = 1;\n    d.mois = 3;\n    d.annee = 1905;\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>Copier une instance de structure<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Vous vous rappelez qu&rsquo;on ne peut pas copier le contenu d&rsquo;un tableau dans un autre avec l&rsquo;op\u00e9rateur <code>=<\/code> ? Il faut proc\u00e9der case par case. Cette limitation est d&rsquo;ailleurs valable pour les cha\u00eenes, puisqu&rsquo;elles sont repr\u00e9sent\u00e9es par des tableaux.<\/p>\n<p>Il est par contre parfaitement possible de copier le contenu d&rsquo;une variable de type structure dans une autre en utilisant l&rsquo;op\u00e9rateur d&rsquo;assignation <code>=<\/code>, comme illustr\u00e9 dans l&rsquo;exemple suivant&#8230;<\/p>\n<pre><code class=\"language-C\">    point p1 = {1.0, 2.0};\n    point p2 = {0.0, 0.0};\n    p2 = p1;\n    printf(\"(%.02f,%.02f)\\n\", p2.x, p2.y);\n<\/code><\/pre>\n<p>&#8230;qui produit l&rsquo;affichage :<\/p>\n<pre><code class=\"language-plain_text\">(1.00,2.00)\n<\/code><\/pre>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x3<\/h5>\n<p>Soient les d\u00e9clarations suivantes :<\/p>\n<pre><code class=\"language-C\">    point p1 = {1.0, 2.0};\n    point p2 = {0.0, 0.0};\n<\/code><\/pre>\n<p>Donnez les lignes de code permettant d&rsquo;\u00e9changer les contenus des variables p1 et p2.<\/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\">    point tmp = p1;\n    p1 = p2;\n    p2 = tmp;\n<\/code><\/pre>\n<p>Remarque : Il est aussi possible d&rsquo;\u00e9changer les valeurs des champs <code>x<\/code> et <code>y<\/code> de chaque variable, mais cela double inutilement la taille du code n\u00e9cessaire.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"f-dec2-tableaux-de-structures\" class=\"anchor\" aria-hidden=\"true\"><\/a>F.dec2 : Tableaux de structures<\/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, C et D<\/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>Repr\u00e9senter des donn\u00e9es complexes en utilisant des tableaux et des structures<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Les structures et les tableaux permettent de repr\u00e9senter des collections de donn\u00e9es de deux mani\u00e8res diff\u00e9rentes. Il peut \u00eatre utile de combiner les deux, soit en cr\u00e9ant des tableaux d&rsquo;instances de structures, soit en int\u00e9grant des tableaux dans des structures, soit les deux. Dans cette section, nous abordons la cr\u00e9ation de tableaux de structures.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>D\u00e9clarer des tableaux de structures<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Un tableau local ou global de structures se d\u00e9clare de la m\u00eame mani\u00e8re qu&rsquo;un tableau local ou global de types scalaires tels que <code>int<\/code> ou <code>double<\/code>, par exemple. La ligne suivante d\u00e9clare un tableaux contenant trois instances de la structure <code>point<\/code> et initialise ce tableau.<\/p>\n<pre><code class=\"language-C\">point tab[3] = {{0.0,1.0}, {1.0, 0.0}, {1.0, 1.0}};\n<\/code><\/pre>\n<p>Un tableau dynamique de structures se cr\u00e9e d&rsquo;une mani\u00e8re similaire \u00e0 celle utilis\u00e9e pour la cr\u00e9ation d&rsquo;un tableau de types scalaires ou pointeurs. Voici un exemple de cr\u00e9ation d&rsquo;un tableau de 3 instances de structures de type <code>point<\/code> dans le tas.<\/p>\n<pre><code class=\"language-C\">point* t = (point*)calloc(3, sizeof(point));\n<\/code><\/pre>\n<p>Les tableaux d\u00e9sign\u00e9s par <code>tab<\/code> et par <code>t<\/code> s&rsquo;utilisent de la m\u00eame mani\u00e8re, mais en cr\u00e9ant le tableau d\u00e9sign\u00e9 par <code>t<\/code>, nous avons contract\u00e9 une dette m\u00e9moire qu&rsquo;il faudra rembourser avant la fin de l&rsquo;ex\u00e9cution du programme par l&rsquo;appel <code>free(t)<\/code>.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x4\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x4<\/h5>\n<p>Donnez les lignes de codes permettant de cr\u00e9er dans le tas un tableau non initialis\u00e9 contenant deux instances de la structure <code>date<\/code>, puis de placer la date repr\u00e9sentant le 7 f\u00e9vrier 2022 dans les deux cellules de ce tableau.<\/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\">    date* td = (date*)malloc(2*sizeof(date));\n    td[0].annee = 2022;\n    td[0].mois = 2;\n    td[0].jour = 7;\n    td[1] = td[0];\n<\/code><\/pre>\n<p>On ne peut pas assigner en une seule fois les valeurs 2022, 2 et 7 aux champs de l&rsquo;instance de <code>date<\/code> situ\u00e9e dans une variable ou dans une cellule d&rsquo;un tableau. La syntaxe <code>= {7, 2, 2022}<\/code> n&rsquo;est utilisable que lors de la d\u00e9claration d&rsquo;une variable de type <code>date<\/code> ou d&rsquo;un tableau global ou automatique d&rsquo;instances de <code>date<\/code>. Ici, la solution utilis\u00e9e consiste \u00e0 assigner un par un les champs de l&rsquo;instance de <code>date<\/code> situ\u00e9e dans la premi\u00e8re cellule du tableau. Mais une fois cette premi\u00e8re cellule assign\u00e9e, on peut utiliser <code>=<\/code> pour en recopier le contenu dans le deuxi\u00e8me cellule du tableau.<\/p>\n<p>On aurait aussi pu proc\u00e9der de la mani\u00e8re suivante :<\/p>\n<pre><code class=\"language-C\">    date* td = (date*)malloc(2*sizeof(date));\n    date tmp = {7, 2, 2022};\n    td[0] = tmp;\n    td[1] = tmp;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"f-dec3-structures-contenant-des-tableaux\" class=\"anchor\" aria-hidden=\"true\"><\/a>F.dec3 : Structures contenant des tableaux<\/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, C et D<\/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>Repr\u00e9senter des donn\u00e9es complexes en utilisant des tableaux et des structures<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Dans la section pr\u00e9c\u00e9dente, nous avons vu comment cr\u00e9er des tableaux de structures. Nous abordons maintenant les diff\u00e9rentes mani\u00e8res de mettre des tableaux dans des structures.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>D\u00e9clarer des structures ayant un ou plusieurs champs de type tableau ou de type pointeur donnant acc\u00e8s \u00e0 des tableaux dynamiques.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Un champ de structure peut \u00eatre un tableau de taille fixe dont le contenu est inclus dans l&rsquo;espace m\u00e9moire occup\u00e9 par une instance de cette structure. Voici un exemple de structure ayant un champ de type tableau de points de taille fixe d\u00e9finie par une constante.<\/p>\n<pre><code class=\"language-C\">#define NMAX 10\n\ntypedef struct\n{\n    int nSommets;\n    point tab[NMAX];\n}polygone;\n<\/code><\/pre>\n<p>Une instance de cette structure repr\u00e9sente un polygone constitu\u00e9 d&rsquo;un nombre de sommets \u00e9gal \u00e0 la valeur du champ <code>nSommets<\/code>.<br \/>\nLe champ <code>tab<\/code> repr\u00e9sente un tableau de taille fixe dont chaque cellule contient une instance de <code>point<\/code>. Seule les <code>nSommets<\/code> premi\u00e8res cellules du tableau <code>tab<\/code> sont utilis\u00e9es.<\/p>\n<p>Par exemple, la d\u00e9claration suivante cr\u00e9e une instance de <code>polygone<\/code> repr\u00e9sentant un triangle.<\/p>\n<pre><code class=\"language-C\">polygone t = {3, {{0.0,0.0}, {0.0,1.0}, {1.0,0.0}}};\n<\/code><\/pre>\n<p>Seules les trois premi\u00e8res cellules du tableau <code>t.tab<\/code> sont utilis\u00e9es. Les 7 autres repr\u00e9sentent un espace de stockage perdu.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x5\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x5<\/h5>\n<p>Donnez la ligne de code permettant de modifier la coordonn\u00e9e <code>x<\/code> du premier point du triangle repr\u00e9sent\u00e9 par l&rsquo;instance de <code>polygone<\/code> contenue dans la variable <code>t<\/code>. La nouvelle valeur doit \u00eatre 2.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\">t.tab[0].x = 2.0;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>L&rsquo;inconv\u00e9nient des tableaux de tailles fixes est qu&rsquo;ils ne permettent pas d&rsquo;optimiser l&rsquo;utilisation de la m\u00e9moire. \u00c0 cet \u00e9gard, il est souvent plus pertinent d&rsquo;utiliser des tableaux dynamiques.<\/p>\n<p>Voici une nouvelle d\u00e9claration de structure ayant le m\u00eame r\u00f4le que la structure <code>polygone<\/code> mais permettant le stockage des points des polygones repr\u00e9sent\u00e9s dans un tableau dynamique.<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    int nSommets;\n    point* tab;\n}poly;\n<\/code><\/pre>\n<p>Il est essentiel de comprendre qu&rsquo;une instance de <code>poly<\/code> ne contient pas le tableau de stockage des sommets, mais seulement un pointeur sur ce tableau. Il faut donc pr\u00e9voir une fonction permettant d&rsquo;initialiser une instance de <code>poly<\/code> en cr\u00e9ant le tableau dynamique de stockage des sommets. Cette initialisation engendrera une \u00ab\u00a0dette m\u00e9moire\u00a0\u00bb qui devra \u00eatre rembours\u00e9e ult\u00e9rieurement en lib\u00e9rant la m\u00e9moire occup\u00e9e par le tableau. Cette tache peut \u00eatre r\u00e9alis\u00e9e par une fonction d\u00e9di\u00e9e.<\/p>\n<p>A ce stade, nous devons faire un choix de conception. Pour comprendre le dilemme qui se profile, il faut faire la diff\u00e9rence entre une structure <strong>monolithique<\/strong>, telle que <code>polygone<\/code>, et une structure <strong>ramifi\u00e9e<\/strong>, telle que <code>poly<\/code>.<\/p>\n<p>Voici la repr\u00e9sentation en m\u00e9moire d&rsquo;une instance de la structure monolithique <code>polygone<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/1-4.png\" alt=\"image-20220208183814040\" \/><\/p>\n<p>On voit que toutes les donn\u00e9es sont regroup\u00e9es dans une seul bloc m\u00e9moire.<\/p>\n<p>Voici maintenant la repr\u00e9sentation en m\u00e9moire d&rsquo;une instance de la structure ramifi\u00e9e <code>poly<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/2-3.png\" alt=\"image-20220208184519006\" \/><\/p>\n<p>Le socle est une instance de <code>poly<\/code> qui peut \u00eatre situ\u00e9e dans la pile ou dans le tas. La ramification est un tableau dynamique qui est n\u00e9cessairement situ\u00e9 dans le tas, car sa taille peut varier selon le nombre de sommets du polygone repr\u00e9sent\u00e9.<\/p>\n<p>Le dilemme \u00e9voqu\u00e9 plus haut est le suivant : doit on placer le socle dans la pile ou dans le tas ? Les deux configurations sont possibles et sont illustr\u00e9es ci dessous.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/3-2.png\" alt=\"image-20220208185533319\" \/><\/p>\n<p>Selon l&rsquo;option adopt\u00e9e, les fonctions d&rsquo;initialisation et de destruction seront diff\u00e9rentes et leur utilisation seront diff\u00e9rentes. Le parti pris de l&rsquo;auteur de cet enseignement est de placer les instances de structures ramifi\u00e9es <strong>enti\u00e8rement dans le tas<\/strong>. Ce choix \u00e9tant fait, voici la fonction permettant de cr\u00e9er une instance de <code>poly<\/code> avec sa ramification.<\/p>\n<pre><code class=\"language-C\">poly* creePoly(int n)\n{\n    poly* out = (poly*)malloc(sizeof(poly)); \/\/ Ligne A\n    out-&gt;nSommets = n;                       \/\/ Ligne B\n    out-&gt;tab = calloc(n,sizeof(point));      \/\/ Ligne C\n    return out;                              \/\/ Ligne D\n}\n<\/code><\/pre>\n<p>Le param\u00e8tre <code>n<\/code> de la fonction repr\u00e9sente le nombre de sommets du polygone \u00e0 cr\u00e9er.<\/p>\n<p><strong>La ligne A<\/strong>, r\u00e9serve dans le tas un bloc m\u00e9moire destin\u00e9 \u00e0 contenir le socle de l&rsquo;instance en cours de construction. L&rsquo;adresse du bloc est plac\u00e9e dans la variable <code>out<\/code>. La taille du bloc \u00e0 cr\u00e9er est fournie par <code>sizeof(poly)<\/code>.<\/p>\n<p><strong>En ligne B<\/strong>, une nouvelle notation <code>-&gt;<\/code> apparait. Elle permet d&rsquo;acc\u00e9der \u00e0 un champ d&rsquo;une instance de structure \u00e0 partir de l&rsquo;adresse m\u00e9moire de cette instance. En fait, <code>out-&gt;n<\/code> est un raccourci pour <code>(*out).n<\/code>, qui d\u00e9signe le champ <code>n<\/code> de l&rsquo;instance de structure <code>poly<\/code> point\u00e9e par <code>out<\/code>. Ce champ re\u00e7oit le nombre de sommets du polygone \u00e0 cr\u00e9er.<\/p>\n<p><strong>La ligne C<\/strong> r\u00e9serve le tableau dynamique destin\u00e9 au stockage des instances de <code>point<\/code> repr\u00e9sentant les points du polygone. Comme la r\u00e9servation est r\u00e9alis\u00e9e par la fonction <code>calloc<\/code>, les coordonn\u00e9es de ces points sont initialis\u00e9es \u00e0 0.0. L&rsquo;adresse du tableau dynamique est plac\u00e9e dans le champ <code>tab<\/code> du socle.<\/p>\n<p><strong>La ligne D<\/strong> retourne l&rsquo;adresse de l&rsquo;instance de <code>poly<\/code> qui vient d&rsquo;\u00eatre cr\u00e9\u00e9e. Cette instance et sa ramification est constitu\u00e9es de deux bloc m\u00e9moire situ\u00e9 dans le tas. Sa cr\u00e9ation engendre donc une double dette m\u00e9moire.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x6\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x6<\/h5>\n<p>Donnez les lignes de code permettant de cr\u00e9er une instance de <code>poly<\/code> repr\u00e9sentant un polygone ayant trois sommets et d&rsquo;assigner les coordonn\u00e9es (2.0,3.0) au premier sommet. Ceci n\u00e9cessite d&rsquo;appeler la fonction <code>creePoly<\/code>, puis d&rsquo;acc\u00e9der aux deux champs <code>x<\/code> et <code>y<\/code> de l&rsquo;instance de <code>point<\/code> situ\u00e9e dans la cellule d&rsquo;indice 0 du tableau d\u00e9sign\u00e9 par le champ <code>tab<\/code> de l&rsquo;instance de <code>poly<\/code> dont l&rsquo;adresse a \u00e9t\u00e9 retourn\u00e9e par l&rsquo;appel de la fonction <code>creePoly<\/code>. N&rsquo;h\u00e9sitez pas \u00e0 relire la phrase pr\u00e9c\u00e9dente, car elle indique que vous devrez utiliser des fl\u00e8ches <code>-&gt;<\/code>, des points <code>.<\/code> et des crochets <code>[ ]<\/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\">    poly* p = creePoly(3);  \/\/ Ligne A\n    p-&gt;tab[0].x = 2.0;      \/\/ Ligne B\n    p-&gt;tab[0].y = 3.0;      \/\/ Ligne C\n<\/code><\/pre>\n<p><strong>La ligne A<\/strong> cr\u00e9e une instance de poly et sa ramification et place l&rsquo;adresse de cette instance dans la variable <code>p<\/code>.<\/p>\n<p><strong>La ligne B<\/strong> acc\u00e8de au champ <code>tab<\/code> de l&rsquo;instance de <code>poly<\/code> <strong>point\u00e9e<\/strong> par <code>p<\/code>. Il faut utiliser la notation <code>p-&gt;tab<\/code> car la variable <code>p<\/code> contient <strong>l&rsquo;adresse<\/strong> de l&rsquo;instance de <code>poly<\/code> dont on veut atteindre le champ <code>tab<\/code>. Comme <code>p-&gt;tab<\/code> d\u00e9signe un tableau, il faut utiliser la notation crochet pour acc\u00e9der \u00e0 la premi\u00e8re cellule de ce tableau qui est <code>p-&gt;tab[0]<\/code>. Cette cellule contient une instance de <code>point<\/code>, et pas une adresse d&rsquo;instance de <code>point<\/code>, c&rsquo;est donc avec la notation <code>.<\/code> et non la notation <code>-&gt;<\/code> qu&rsquo;on acc\u00e8de au champ <code>x<\/code> de cette instance, d&rsquo;o\u00f9 l&rsquo;expression <code>p-&gt;tab[0].x<\/code>.<\/p>\n<p><strong>La ligne C<\/strong> est \u00e9vidente quand on a compris la ligne B.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x7\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x7<\/h5>\n<p>D\u00e9finissez la fonction&#8230;<\/p>\n<pre><code class=\"language-C\">void setSommet(poly* p, int i, double x, double y);\n<\/code><\/pre>\n<p>&#8230;qui assigne les coordonn\u00e9es <code>(x,y)<\/code> au sommet <code>i<\/code> du polygone repr\u00e9sent\u00e9 par l&rsquo;instance de <code>poly<\/code> d\u00e9sign\u00e9e par <code>p<\/code>. On suppose que cette instance de <code>poly<\/code> a \u00e9t\u00e9 pr\u00e9alablement cr\u00e9\u00e9e par un appel \u00e0 la fonction <code>creePoly<\/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 setSommet(poly* p, int i, double x, double y)\n{\n    p-&gt;tab[i].x = x;\n    p-&gt;tab[i].y = y;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Revenons sur la dette m\u00e9moire contract\u00e9e lors de la cr\u00e9ation par la fonction <code>creePoly<\/code> d&rsquo;une instance de <code>poly<\/code> et de sa ramification. Une telle instance est constitu\u00e9e de deux blocs m\u00e9moire, donc sa destruction n\u00e9cessite deux appels \u00e0 la fonction <code>free<\/code>. Voici une fonction r\u00e9alisant ces op\u00e9rations.<\/p>\n<pre><code class=\"language-C\">void deletePoly(poly* p)\n{\n    free(p-&gt;tab);\n    free(p);\n}\n<\/code><\/pre>\n<p>L&rsquo;ordre des lignes est important. Il faut d&rsquo;abord lib\u00e9rer le bloc occup\u00e9 part le tableau, puis le bloc occup\u00e9 par le socle. Seul les blocs m\u00e9moire r\u00e9serv\u00e9s par <code>malloc<\/code> ou <code>calloc<\/code> doivent \u00eatre lib\u00e9r\u00e9s (donc pas le champ <code>nSommet<\/code>).<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x8\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x8<\/h5>\n<p>D\u00e9finissez une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">void printPoint(point* p);\n<\/code><\/pre>\n<p>&#8230;qui affiche les coordonn\u00e9es d&rsquo;un point repr\u00e9sent\u00e9 par une instance de la structure <code>point<\/code> d\u00e9finie plus haut. L&rsquo;affichage doit \u00eatre de la forme <code>(1.0,2.0)<\/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 printPoint(point* p)\n{\n    printf(\"(%.02f,%.02f)\", p-&gt;x, p-&gt;y);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x9\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x9<\/h5>\n<p>D\u00e9finissez une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">void printPoly(poly* p);\n<\/code><\/pre>\n<p>&#8230;qui affiche la liste des sommets du polygone repr\u00e9sent\u00e9 par l&rsquo;instance de <code>poly<\/code> d\u00e9sign\u00e9e par <code>p<\/code>. Cette fonction doit appeler la fonction <code>printPoint<\/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 printPoly(poly* p)\n{\n    for(int i = 0; i&lt;p-&gt;nSommets; i++)\n    {\n        printPoint(&amp;(p-&gt;tab[i]));\n    }\n    printf(\"\\n\");\n}\n<\/code><\/pre>\n<p>Notez l&rsquo;utilisation de <code>&amp;<\/code> pour r\u00e9cup\u00e9rer l&rsquo;adresse de l&rsquo;instance de point repr\u00e9sentant chacun des points \u00e0 afficher. En effet, <code>printPoint<\/code> accepte en param\u00e8tre un pointeur sur <code>point<\/code>. Mais <code>p-&gt;tab[i]<\/code> est le contenu d&rsquo;une cellule d&rsquo;un tableau d&rsquo;instance de <code>point<\/code>. Une telle cellule contient une instance de <code>point<\/code>, pas un pointeur. Pour obtenir l&rsquo;adresse de cette instance on doit \u00e9crire <code>&amp;(p-&gt;tab[i]<\/code>).<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x10\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x10<\/h5>\n<p>Donnez les lignes de code permettant de cr\u00e9er une instance de <code>poly<\/code> repr\u00e9sentant un polygone ayant trois sommets, d&rsquo;assigner les coordonn\u00e9es (1.0, 2.0), (2.0, 1.0), et (1.0, 1.0) \u00e0 ces sommets, puis d&rsquo;afficher le polygone par un appel \u00e0 <code>printPoly<\/code>, puis de lib\u00e9rer la m\u00e9moire r\u00e9serv\u00e9e dans le tas.<\/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\">    poly* p = creePoly(3);\n    setSommet(p, 0, 1.0, 2.0);\n    setSommet(p, 1, 2.0, 1.0);\n    setSommet(p, 2, 1.0, 1.0);\n    printPoly(p);\n    deletePoly(p);\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<h3><a id=\"f-dec4-copie-en-profondeur\" class=\"anchor\" aria-hidden=\"true\"><\/a>F.dec4 : Copie en profondeur<\/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>Sections F.dec1 et F.dec2<\/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>Dupliquer ou copier des instances de structures sans cr\u00e9er d&rsquo;effets de bord, fuite m\u00e9moire ou accident m\u00e9moire.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Pour illustrer la notion de copie superficielle et ses inconv\u00e9nients, consid\u00e9rons le petit exemple suivant :<\/p>\n<pre><code class=\"language-C\">void test(void)\n{\n    poly* p = creePoly(3);\n    setSommet(p, 0, 1.0, 2.0);\n    setSommet(p, 1, 2.0, 1.0);\n    setSommet(p, 2, 1.0, 1.0);\n    poly* q = p;                \/\/ Ligne A\n    setSommet(q ,0, 9.0, 7.0); \n    printPoly(p);\n    printPoly(q);\n    deletePoly(p);\n}\n<\/code><\/pre>\n<p>L&rsquo;affichage produit est le suivant :<\/p>\n<pre><code class=\"language-plain_text\">(9.00,7.00)(2.00,1.00)(1.00,1.00)\n(9.00,7.00)(2.00,1.00)(1.00,1.00)\n<\/code><\/pre>\n<p>On constate que la modification du polygone d\u00e9sign\u00e9 par <code>q<\/code> a impact\u00e9 celui d\u00e9sign\u00e9 par <code>p<\/code>. Et pour cause ! <code>p<\/code> et <code>q<\/code> d\u00e9signent la m\u00eame instance de <code>poly<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/4-2.png\" alt=\"image-20220208212406794\" \/><\/p>\n<p>Tentons une autre approche.<\/p>\n<pre><code class=\"language-C\">void test(void)\n{\n    poly* p = creePoly(3);\n    setSommet(p, 0, 1.0, 2.0);\n    setSommet(p, 1, 2.0, 1.0);\n    setSommet(p, 2, 1.0, 1.0);\n    poly* q = creePoly(3);\n    *q = *p;                    \/\/ Ligne A\n    setSommet(q ,0, 9.0, 7.0);\n    printPoly(p);\n    printPoly(q);\n    deletePoly(p);\n    deletePoly(q);\n}\n<\/code><\/pre>\n<p>Une premi\u00e8re instance de <code>poly<\/code> est cr\u00e9\u00e9e et son adresse est plac\u00e9e dans <code>p<\/code>. Ses sommets sont assign\u00e9s, puis une deuxi\u00e8me instance de <code>poly<\/code> est cr\u00e9\u00e9e et plac\u00e9e dans <code>q<\/code>. On arrive \u00e0 la <strong>ligne A<\/strong> o\u00f9 l&rsquo;instance de <code>poly<\/code> point\u00e9e par <code>p<\/code> est copi\u00e9e par l&rsquo;op\u00e9rateur d&rsquo;assignation <code>=<\/code> dans l&rsquo;instance de poly point\u00e9e par <code>q<\/code>.<\/p>\n<p>\u00c0 l&rsquo;ex\u00e9cution, on constate l&rsquo;affichage suivant&#8230;<\/p>\n<pre><code class=\"language-plain_text\">(9.00,7.00)(2.00,1.00)(1.00,1.00)\n(9.00,7.00)(2.00,1.00)(1.00,1.00)\n<\/code><\/pre>\n<p>&#8230; accompagn\u00e9e d&rsquo;un crash du programme pour faire bonne mesure. La modification de l&rsquo;instance de <code>poly<\/code> d\u00e9sign\u00e9e par <code>q<\/code> a encore impact\u00e9 celle d\u00e9sign\u00e9e par p.<\/p>\n<p>Pour expliquer ce qui c&rsquo;est pass\u00e9, observons la configuration en m\u00e9moire juste apr\u00e8s l&rsquo;ex\u00e9cution de la <strong>ligne A<\/strong>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/5-1.png\" alt=\"image-20220208214603678\" \/><\/p>\n<p>L&rsquo;assignation <code>*q = *p<\/code> a recopi\u00e9 le contenu de l&rsquo;instance de <code>poly<\/code> point\u00e9e par <code>p<\/code> dans celle point\u00e9e par <code>q<\/code>. Mais il s&rsquo;agit d&rsquo;une <strong>copie superficielle<\/strong>. Les valeurs des champs de la premi\u00e8re instance ont \u00e9t\u00e9 copi\u00e9es dans les champs de la deuxi\u00e8me. Il en r\u00e9sulte que les champs <code>tab<\/code> des deux instances pointent le m\u00eame tableau. Ceci entra\u00eene plusieurs cons\u00e9quence f\u00e2cheuses :<\/p>\n<ol>\n<li>Un effet de bord : toute modification d&rsquo;un sommet du polygone d\u00e9sign\u00e9 par <code>q<\/code> impacte celui d\u00e9sign\u00e9 par <code>p<\/code>, puisque les points de ces deux polygones sont stock\u00e9s dans le m\u00eame tableau.<\/li>\n<li>Une fuite m\u00e9moire, puisque la m\u00e9moire occup\u00e9e pas l&rsquo;ancien tableau des sommets du polygone d\u00e9sign\u00e9 par <code>q<\/code> n&rsquo;est pas lib\u00e9r\u00e9e.<\/li>\n<li>Un accident m\u00e9moire, puisque la m\u00e9moire occup\u00e9e par le tableaux de points partag\u00e9 par les polygones d\u00e9sign\u00e9s par <code>p<\/code> et <code>q<\/code> est lib\u00e9r\u00e9e deux fois.<\/li>\n<\/ol>\n<p>En conclusion, la copie d&rsquo;instances de structures avec l&rsquo;op\u00e9rateur <code>=<\/code> fonctionne bien avec les structures monolithiques, mais pose probl\u00e8me avec les structures ramifi\u00e9es.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>La copie en profondeur d&rsquo;une structure ramifi\u00e9e.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Nous allons \u00e0 pr\u00e9sent voir comment cr\u00e9er un <strong>clone<\/strong> d&rsquo;une structure ramifi\u00e9e en nous basant sur le cas de la structure <code>poly<\/code>.<\/p>\n<p>Le but est de d\u00e9finir une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">poly* clonePoly(poly* p);\n<\/code><\/pre>\n<p>&#8230;permettant de cr\u00e9er une nouvelle instance de <code>poly<\/code> et sa ramification en prenant comme mod\u00e8le l&rsquo;instance de <code>poly<\/code> d\u00e9sign\u00e9e par <code>p<\/code>. La nouvelle instance doit \u00eatre compl\u00e8tement ind\u00e9pendante de celle ayant servi de mod\u00e8le. Toute modification ult\u00e9rieure de l&rsquo;une des deux instances ne devra avoir aucun effet sur l&rsquo;autre.<\/p>\n<p>Voici un exemple d&rsquo;utilisation :<\/p>\n<pre><code class=\"language-C\">void test5(void)\n{\n    poly* p = creePoly(3);\n    setSommet(p, 0, 1.0, 2.0);\n    setSommet(p, 1, 2.0, 1.0);\n    setSommet(p, 2, 1.0, 1.0);\n    poly* q = clonePoly(p);\n    setSommet(q ,0, 9.0, 7.0); \/\/ Ligne A\n    printPoly(p);\n    printPoly(q);\n    deletePoly(p);\n    deletePoly(q);\n}\n<\/code><\/pre>\n<p>L&rsquo;affichage attendu est :<\/p>\n<pre><code class=\"language-plain_text\">(1.00,2.00)(2.00,1.00)(1.00,1.00)\n(9.00,7.00)(2.00,1.00)(1.00,1.00)\n<\/code><\/pre>\n<p>Il montre que la modification d&rsquo;un sommet du polygone d\u00e9sign\u00e9 par <code>q<\/code>, en ligne A, n&rsquo;affecte pas celui d\u00e9sign\u00e9 par <code>q<\/code>.<\/p>\n<p>Voici le code de la fonction <code>clonePoly<\/code> :<\/p>\n<pre><code class=\"language-C\">poly* clonePoly(poly* p)\n{\n    poly* out = creePoly(p-&gt;nSommets);\n    for(int i=0; i&lt; p-&gt;nSommets; i++)\n    {\n        out-&gt;tab[i] = p-&gt;tab[i];\n    }\n    return out;\n}\n<\/code><\/pre>\n<p>Elle fait appel \u00e0 la fonction <code>creePoly<\/code> pour cr\u00e9er un nouveau polygone, puis recopie les sommets du polygone mod\u00e8le dans le tableau de stockage des sommets du nouveau polygone. Les sommets \u00e9tant des instance de <code>point<\/code>, qui est une structure monolithique, il peuvent \u00eatre copi\u00e9s avec l&rsquo;op\u00e9rateur d&rsquo;assignation <code>=<\/code>.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x11\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x11<\/h5>\n<p>Vous devez d\u00e9finir une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">void exgPoly(poly* p1, poly* p2);\n<\/code><\/pre>\n<p>&#8230;qui \u00e9change les polygones d\u00e9sign\u00e9s par <code>p1<\/code> et <code>p2<\/code>. Ce polygones n&rsquo;ont pas n\u00e9cessairement le m\u00eame nombre de sommets. Voici un exemple de configuration en m\u00e9moire avant appel de la fonction :<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/6.png\" alt=\"image-20220209104934700\" \/><\/p>\n<p>Apr\u00e8s l&rsquo;ex\u00e9cution de la ligne de code suivante&#8230;<\/p>\n<pre><code class=\"language-C\">  exgPoly(p, q);\n<\/code><\/pre>\n<p>&#8230;la nouvelle situation en m\u00e9moire doit \u00eatre celle-ci :<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/7.png\" alt=\"image-20220209105301691\" \/><\/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 exgPoly(poly* p1, poly* p2)\n{\n    poly tmp = *p1;\n    *p1 = *p2;\n    *p2 = tmp;\n}\n<\/code><\/pre>\n<p>En g\u00e9n\u00e9ral, l&rsquo;utilisation de <code>=<\/code> pour copier des structures ramifi\u00e9e est probl\u00e9matique. Mais dans ce cas particulier, comme on conserve les tableaux de stockage des deux polygones, la copie superficielle est utilisable et est m\u00eame la solution la plus simple.<\/p>\n<p>Mais il serait aussi possible d&rsquo;\u00e9crire :<\/p>\n<pre><code class=\"language-C\">void exgPolyBis(poly* p1, poly* p2)\n{\n    int tmp1 = p1-&gt;nSommets;\n    p1-&gt;nSommets = p2-&gt;nSommets;\n    p2-&gt;nSommets = tmp1;\n    point* tmp2 = p1-&gt;tab;\n    p1-&gt;tab = p2-&gt;tab;\n    p2-&gt;tab = tmp2;\n}\n<\/code><\/pre>\n<p>Sachant que ce ne sont pas les contenus des tableaux, mais leur adresses qui sont \u00e9chang\u00e9es, comme le montre l&rsquo;illustration pr\u00e9c\u00e9dente.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"f-dec5-fonctions-et-structures\" class=\"anchor\" aria-hidden=\"true\"><\/a>F.dec5 : Fonctions et structures<\/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>Sections F.dec1, F.dec2 et F.dec3<\/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 des fonctions qui ont des param\u00e8tres de type structure et \/ ou retournent des instances de structures.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Nous avons d\u00e9fini et utilis\u00e9, dans la section pr\u00e9c\u00e9dente, des fonctions acceptant en param\u00e8tres des pointeurs sur des structures et \/ ou retournant des pointeurs sur des structures. L&rsquo;utilisation de param\u00e8tres de type pointeur et de valeurs de retour de type pointeur n&rsquo;\u00e9tait pas un concept nouveau. On peut passer des pointeurs en param\u00e8tres \u00e0 des fonctions et il n&rsquo;y a aucune restriction quand aux types des donn\u00e9es point\u00e9es.<\/p>\n<p>Mais contrairement aux tableaux, les structures peuvent \u00eatre pass\u00e9es en param\u00e8tres \u00e0 des fonctions <strong>par copie<\/strong>. Nous allons d\u00e9couvrir les possibilit\u00e9s offertes par cette nouveaut\u00e9, et les limites d&rsquo;utilisation raisonnable du concept.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Le passage en param\u00e8tre par copie et l&rsquo;assignation avec = de structures monolithiques<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Revenons \u00e0 la structure <code>point<\/code> d\u00e9finie dans la section F.dec1.<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    double x;\n    double y;\n}point;\n<\/code><\/pre>\n<p>Dans la section F.dec3, nous avons d\u00e9fini une fonction permettant d&rsquo;afficher les coordonn\u00e9e d&rsquo;un point repr\u00e9sent\u00e9 par une instance de la structure <code>point<\/code>.<\/p>\n<pre><code class=\"language-C\">void printPoint(point* p)\n{\n    printf(\"(%.02f,%.02f)\", p-&gt;x, p-&gt;y);\n}\n<\/code><\/pre>\n<p>Cette fonction a un param\u00e8tre de type pointeur sur <code>point<\/code>. On doit donc lui passer en argument l&rsquo;adresse d&rsquo;une instance de <code>point<\/code>, et c&rsquo;est la raison pour laquelle les notations <code>p-&gt;x<\/code> et <code>p-&gt;y<\/code> sont utilis\u00e9es pour r\u00e9cup\u00e9rer les valeurs des coordonn\u00e9es \u00e0 afficher.<\/p>\n<p>Mais il est possible de r\u00e9aliser une variante de cette fonction qui a un param\u00e8tre de type <code>point<\/code>.<\/p>\n<pre><code class=\"language-C\">void displayPoint(point p)\n{\n    printf(\"(%.02f,%.02f)\", p.x, p.y);\n}\n<\/code><\/pre>\n<p>Les deux fonctions ne s&rsquo;appellent pas de la m\u00eame mani\u00e8re, puisque leur param\u00e8tres ont des types diff\u00e9rents. Voici un exemple :<\/p>\n<pre><code class=\"language-C\">    point w ={3.5, 2.0};\n    printPoint(&amp;w);\n    printf(\" \");\n    displayPoint(w);\n    printf(\"\\n\");\n<\/code><\/pre>\n<p>L&rsquo;argument de l&rsquo;appel \u00e0 <code>printPoint<\/code> est l&rsquo;adresse de l&rsquo;instance de <code>point<\/code> contenue dans <code>w<\/code>.<\/p>\n<p>L&rsquo;argument de l&rsquo;appel \u00e0 <code>displayPoint<\/code> est l&rsquo;instance de <code>point<\/code> contenue dans <code>w<\/code>. Plus pr\u00e9cis\u00e9ment, cette instance de point est <strong>recopi\u00e9e<\/strong> dans le param\u00e8tre <code>p<\/code> de la fonction <code>displayPoint<\/code>.<\/p>\n<p>Le fait de pouvoir passer une instance de structure en param\u00e8tre par copie \u00e0 une fonction peut permettre de simplifier la d\u00e9finition et l&rsquo;utilisation de cette fonction, au prix d&rsquo;une l\u00e9g\u00e8re perte d&rsquo;efficacit\u00e9. En effet, un pointeur et une instance de <code>point<\/code> n&rsquo;ont pas la m\u00eame taille en m\u00e9moire. Si on ex\u00e9cute la ligne suivante&#8230;<\/p>\n<pre><code class=\"language-C\">    printf(\"%ld, %ld\\n\", sizeof(point*), sizeof(point));\n<\/code><\/pre>\n<p>&#8230;on obtient l&rsquo;affichage :<\/p>\n<pre><code class=\"language-C\">8, 16\n<\/code><\/pre>\n<p>Sur la machine utilis\u00e9e pour faire l&rsquo;exp\u00e9rience, un pointeur sur <code>point<\/code> occupe 8 octets en m\u00e9moire alors qu&rsquo;une instance de <code>point<\/code> en occupe 16.<\/p>\n<p>Lors de l&rsquo;appel \u00e0 <code>printPoint<\/code>, 8 octets sont recopi\u00e9s dans son param\u00e8tre, alors que lors de l&rsquo;appel de <code>displayPoint<\/code> ce sont 16 octets qui sont copi\u00e9s, ce qui augmente \u00e0 la fois le temps CPU et la quantit\u00e9 de m\u00e9moire consomm\u00e9s.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x12\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x12<\/h5>\n<p>On d\u00e9finit une structure <code>couple<\/code> repr\u00e9sentant des couples constitu\u00e9s de deux points.<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    point a;\n    point b;\n}couple;\n<\/code><\/pre>\n<p>D\u00e9finissez une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">void displayCouple(couple w);\n<\/code><\/pre>\n<p>&#8230; qui affiche un couple en appelant la fonction <code>displayPoint<\/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 displayCouple(couple w)\n{\n    printf(\"[\");\n    displayPoint(w.a);\n    printf(\",\");\n    displayPoint(w.b);\n    printf(\"]\");\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x13\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x13<\/h5>\n<p>D\u00e9finissez une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">void printCouple(couple* w);\n<\/code><\/pre>\n<p>&#8230; qui affiche un couple en appelant la fonction <code>printPoint<\/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 printCouple(couple* w)\n{\n    printf(\"[\");\n    printPoint(&amp;(w-&gt;a));\n    printf(\",\");\n    printPoint(&amp;(w-&gt;b));\n    printf(\"]\");\n}\n<\/code><\/pre>\n<p>Faites attention \u00e0 ne pas vous emp\u00eatrer dans le syntaxe. Comme <code>w<\/code> pointe une instance de <code>couple<\/code>, on acc\u00e8de au champ <code>a<\/code> de cette instance avec la notation <code>w-&gt;a<\/code>. Mais comme le champ <code>a<\/code> contient une instance de <code>point<\/code> (et non un pointeur), il faut utiliser la notation <code>&amp;(w-&gt;a)<\/code> pour obtenir l&rsquo;adresse de cette instance de <code>point<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Non seulement une fonction peut avoir des param\u00e8tres de type structure, mais elle peut \u00e9galement <strong>retourner une valeur de type structure<\/strong>, c&rsquo;est \u00e0 dire une instance de structure.<\/p>\n<p>Par exemple, la fonction suivante retourne le milieu du segment ayant pour extr\u00e9mit\u00e9s les deux points repr\u00e9sent\u00e9s par ses param\u00e8tres <code>e1<\/code> et <code>e2<\/code> :<\/p>\n<pre><code class=\"language-C\">point milieu(point e1, point e2)\n{\n    point m;\n    m.x = (e1.x + e2.x) \/ 2.0;\n    m.y = (e1.y + e2.y) \/ 2.0;\n    return m;\n}\n<\/code><\/pre>\n<p>Cette fonction cr\u00e9e une nouvelle instance de <code>point<\/code>, la \u00ab\u00a0garnit\u00a0\u00bb avec les coordonn\u00e9es du milieu du segment, puis retourne une <strong>copie<\/strong> de cette instance de <code>point<\/code>. La variable locale <code>m<\/code> est d\u00e9truite \u00e0 l&rsquo;issue de l&rsquo;ex\u00e9cution de la fonction <code>milieu<\/code>, mais une copie de sa valeur est retourn\u00e9e et peut \u00eatre r\u00e9cup\u00e9r\u00e9e dans une variable, comme dans l&rsquo;exemple suivant :<\/p>\n<pre><code class=\"language-C\">    point pt1 = {1.0, 2.0};\n    point pt2 = {3.0, 4.0};\n    point m = milieu(pt1, pt2);\n    displayPoint(m);\n<\/code><\/pre>\n<p>On peut m\u00eame \u00e9crire :<\/p>\n<pre><code class=\"language-C\">    displayPoint(milieu(pt1, pt2));\n<\/code><\/pre>\n<p>Dans ce cas, l&rsquo;instance de <code>point<\/code> retourn\u00e9e par <code>milieu<\/code> est transmise directement \u00e0 <code>displayPoint<\/code>.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x14\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x14<\/h5>\n<p>D\u00e9finissez la fonction&#8230;<\/p>\n<pre><code class=\"language-C\">point mil(couple c);\n<\/code><\/pre>\n<p>&#8230;qui retourne l&rsquo;instance de <code>point<\/code> repr\u00e9sentant le milieu du segment ayant pour extr\u00e9mit\u00e9s les points du couple d\u00e9sign\u00e9 par <code>c<\/code>. La fonction <code>mil<\/code> doit appeler la fonction <code>milieu<\/code> pr\u00e9c\u00e9demment d\u00e9finie.<\/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>Voici une solution simple et concise :<\/p>\n<pre><code class=\"language-C\">point mil(couple c)\n{\n    return milieu(c.a, c.b);\n}\n<\/code><\/pre>\n<p>Mais on peut aussi \u00e9crire :<\/p>\n<pre><code class=\"language-C\">point mil(couple c)\n{\n    point m = milieu(c.a, c.b);\n    return m;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p><strong>En r\u00e9sum\u00e9 :<\/strong><\/p>\n<ul>\n<li>Les fonctions \u00e0 param\u00e8tres de type structure sont un peu plus faciles \u00e0 utiliser et \u00e0 impl\u00e9menter que les fonctions \u00e0 param\u00e8tres de type pointeurs sur des structures, mais leur ex\u00e9cution est un peu moins efficace, ce qui n&rsquo;est pas n\u00e9cessairement un probl\u00e8me.<\/li>\n<li>Les fonctions retournant des structures ont le m\u00eame avantage et le m\u00eame d\u00e9faut. Elle permettent aussi souvent de simplifier le code source d&rsquo;un programme et leur utilisation ne pose aucun probl\u00e8me \u00e0 part un l\u00e9g\u00e8re perte d&rsquo;efficacit\u00e9.<\/li>\n<\/ul>\n<p>Mais attention, <strong>l&rsquo;utilisation de fonctions retournant des instances de structures ramifi\u00e9es peut poser probl\u00e8me<\/strong>. Ce point ne sera pas d\u00e9velopp\u00e9 (mais vous pouvez r\u00e9fl\u00e9chir \u00e0 la question par vous-m\u00eame). Dans la suite, nous \u00e9viterons de d\u00e9finir de telles fonctions.<\/p>\n<h3><a id=\"f-dec6-compl%C3%A9ments\" class=\"anchor\" aria-hidden=\"true\"><\/a>F.dec6 : Compl\u00e9ments<\/h3>\n<p>Le concept de structure pr\u00e9sent\u00e9 dans cette partie ouvre de tr\u00e8s nombreuses possibilit\u00e9s. Il est difficile d&rsquo;\u00eatre exhaustif sur le sujet et je n&rsquo;ai pas cet objectif. Il y a toutefois deux choses importantes qui n&rsquo;ont pas encore \u00e9t\u00e9 abord\u00e9es : les variantes de syntaxe et la comparaison d&rsquo;instances de structures.<\/p>\n<h4><a id=\"variantes-de-d%C3%A9clarations-de-structures\" class=\"anchor\" aria-hidden=\"true\"><\/a>Variantes de d\u00e9clarations de structures<\/h4>\n<p>Il existe une autre syntaxe que celle pr\u00e9sent\u00e9e plus haut pour la d\u00e9claration de structures, que nous appellerons \u00ab\u00a0forme ancienne\u00a0\u00bb.<\/p>\n<p>La d\u00e9claration&#8230;<\/p>\n<pre><code class=\"language-C\">struct spoint\n{\n    double x;\n    double y;\n};\n<\/code><\/pre>\n<p>&#8230; d\u00e9finit le type <code>struct spoint<\/code>. \u00c0 l&rsquo;utilisation, il faut \u00e0 chaque fois \u00e9crire <code>struct spoint<\/code>. On peut ensuite \u00e9crire&#8230;<\/p>\n<pre><code class=\"language-C\">typedef struct spoint point;\n<\/code><\/pre>\n<p>&#8230; pour d\u00e9finir une notation raccourcie <code>point<\/code> \u00e9quivalente \u00e0 <code>struct point<\/code>..<\/p>\n<p>La d\u00e9claration vue en d\u00e9but de cette partie&#8230;<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    double x;\n    double y;\n}point;\n<\/code><\/pre>\n<p>&#8230;est en quelques sorte une contraction des deux d\u00e9clarations pr\u00e9c\u00e9dentes.<\/p>\n<p>La forme ancienne n&rsquo;a d&rsquo;int\u00e9r\u00eat que lors de la d\u00e9claration de structures autor\u00e9f\u00e9rentes, c&rsquo;est \u00e0 dire de structures ayant un champ de type pointeur sur leur propre type. Comme nous n&rsquo;aborderons pas ce sujet, nous utiliseront toujours la forme simplifi\u00e9e.<\/p>\n<h4><a id=\"comparaison-d-instances-de-structures\" class=\"anchor\" aria-hidden=\"true\"><\/a>Comparaison d&rsquo;instances de structures<\/h4>\n<p>Nous avons vu que les instances de structures peuvent \u00eatre copi\u00e9es avec l&rsquo;op\u00e9rateur d&rsquo;assignation <code>=<\/code>. Par contre elles ne peuvent pas \u00eatres compar\u00e9es avec <code>==<\/code> ou <code>!=<\/code>, <code>&gt;<\/code>, <code>&lt;<\/code>, etc.<\/p>\n<p>Par exemple, on pourrait avoir besoin de comparer des instances de la structure <code>date<\/code> d\u00e9finie dans le section F.dec1.<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    char jour;\n    char mois;\n    int annee;\n}date;\n<\/code><\/pre>\n<p>Mais si <code>d1<\/code> et <code>d2<\/code> sont des variables de type <code>date<\/code>, on ne peut \u00e9crire quelque chose dans le genre :<\/p>\n<pre><code class=\"language-C\">    if(d1==d2)\n    {\n        \u2026\u2026\u2026\u2026\u2026\n    }\n<\/code><\/pre>\n<p>Pour comparer des instances d&rsquo;un type structure, il faut d\u00e9finir une fonction sp\u00e9cifique.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-f-dec-x15\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte F.dec.x15<\/h5>\n<p>D\u00e9finissez une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">int compareDate(date d1, date d2);\n<\/code><\/pre>\n<p>&#8230; qui retourne un entier n\u00e9gatif si la date d\u00e9sign\u00e9e par <code>d1<\/code> est ant\u00e9rieure \u00e0 celle d\u00e9sign\u00e9e par <code>d2<\/code>, une valeur positive si la date d\u00e9sign\u00e9e par <code>d1<\/code> est post\u00e9rieure \u00e0 celle d\u00e9sign\u00e9e par <code>d2<\/code>, et la valeur 0 si les deux dates sont identiques.<\/p>\n<p><strong>Remarque<\/strong> : si les ann\u00e9es sont diff\u00e9rentes, nul besoin de prendre en compte les jours et les mois pour conclure. Si les ann\u00e9es sont identiques et les mois diff\u00e9rents, nul besoin de comparer les jours. Si les ann\u00e9es et les mois sont identiques, le r\u00e9sultat d\u00e9pend uniquement des jours.<\/p>\n<pre><code class=\"language-C\">int compareDate(date d1, date d2)\n{\n    if(d1.annee != d2.annee) return d1.annee - d2.annee;\n    else if(d1.mois != d2.mois) return d1.mois - d2.mois;\n    else return d1.jour - d2.jour;\n}\n<\/code><\/pre>\n<hr \/>\n<h2><a id=\"activit%C3%A9-d-entra%C3%AEnement-f-ent\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 d&rsquo;entra\u00eenement F.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-f-ent1\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration F.ent1<\/h3>\n<h4><a id=\"exercice-d-entrainement-f-ent1-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement F.ent1.1<\/h4>\n<p>On reprend la structure <code>point<\/code> :<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    double x;\n    double y;\n}point;\n<\/code><\/pre>\n<p>Vous devez d\u00e9finir une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">point sym(point w);\n<\/code><\/pre>\n<p>&#8230;retournant le point sym\u00e9trique de celui d\u00e9sign\u00e9 par le param\u00e8tre <code>w<\/code>. Le sym\u00e9trique d&rsquo;un point est obtenu en \u00e9changeant ses coordonn\u00e9es &#40;x&#41; et &#40;y&#41;.<\/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\">point sym(point w)\n{\n    point out;\n    \/\/ \u00c0 compl\u00e9ter\n    return out;\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\">point sym(point w)\n{\n    point out;\n    out.x = w.y;\n    out.y = w.x;\n    return out;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Vous devez d\u00e9finir la variante suivante de fonction <code>sym<\/code>, qui retourne le sym\u00e9trique du point d\u00e9sign\u00e9 par <code>p<\/code> :<\/p>\n<pre><code class=\"language-C\">point sym1(point* p);\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\">point sym1(point* p)\n{\n    point out;\n    out.x = p-&gt;y;\n    out.y = p-&gt;x;\n    return out;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Donnez les lignes de code permettant :<\/p>\n<ol>\n<li>De d\u00e9clarer une variable <code>p1<\/code> de type <code>point<\/code> initialis\u00e9e avec une instance de <code>point<\/code> repr\u00e9sentant le point de coordonn\u00e9es \\((1.0,3.0)\\).<\/li>\n<li>De placer dans une variable <code>p2<\/code> de type <code>point<\/code> une instance de <code>point<\/code> repr\u00e9sentant le sym\u00e9trique du point repr\u00e9sent\u00e9 par le contenu de <code>p1<\/code>, produit par un appel \u00e0 la fonction <code>sym<\/code>.<\/li>\n<li>De placer dans une variable <code>p3<\/code> de type <code>point<\/code> une instance de <code>point<\/code> repr\u00e9sentant le sym\u00e9trique du point repr\u00e9sent\u00e9 par le contenu de <code>p2<\/code>, produit par un appel \u00e0 la fonction <code>sym1<\/code>.<\/li>\n<li>D&rsquo;afficher la valeur de <code>p3<\/code> \u00e0 l&rsquo;aide de la fonction <code>displayPoint<\/code>.<\/li>\n<li>D&rsquo;afficher la valeur de <code>p3<\/code> \u00e0 l&rsquo;aide de la fonction <code>printPoint<\/code>.<\/li>\n<\/ol>\n<p>Pour m\u00e9moire, voici les d\u00e9clarations des fonctions d&rsquo;affichage :<\/p>\n<pre><code class=\"language-C\">void printPoint(point* p)\nvoid displayPoint(point p)\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\">    point p1 = {1.0, 3.0};\n    point p2 = sym(p1);\n    point p3 = sym1(&amp;p2);\n    displayPoint(p3);\n    printPoint(&amp;p3);\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-f-ent1-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement F.ent1.2<\/h4>\n<p>On d\u00e9finit la structure suivante repr\u00e9sentant un point inform\u00e9, c&rsquo;est \u00e0 dire un point ayant un nom repr\u00e9sent\u00e9 par une cha\u00eene.<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    point pt;\n    char* nom;\n}iPoint;\n<\/code><\/pre>\n<p>D\u00e9finissez la fonction&#8230;<\/p>\n<pre><code class=\"language-C\">iPoint* creePoint(double x, double y, const char* nom);\n<\/code><\/pre>\n<p>&#8230;permettant de cr\u00e9er une instance de <code>iPoint<\/code> et sa ramification (la chaine contenant le nom du point) situ\u00e9e compl\u00e8tement dans le tas. Une telle instance, avec sa ramification, est constitu\u00e9e de deux blocs m\u00e9moire. La cha\u00eene contenant le nom du point cr\u00e9\u00e9 doit \u00eatre une <strong>copie<\/strong> de la cha\u00eene d\u00e9sign\u00e9e par le param\u00e8tre <code>nom<\/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 solution partielle, \u00e0 compl\u00e9ter :<\/p>\n<pre><code class=\"language-C\">iPoint* creePoint(double x, double y, const char* nom)\n{\n    iPoint* out = (iPoint*)malloc(sizeof(iPoint));\n    \/\/ \u00c0 compl\u00e9ter\n    return out;\n}\n<\/code><\/pre>\n<p>Il reste \u00e0 :<\/p>\n<ul>\n<li>Placer les valeurs <code>x<\/code> et <code>y<\/code> dans les champs <code>x<\/code> et <code>y<\/code> de l&rsquo;instance de structure point\u00e9e par <code>out<\/code>.<\/li>\n<li>R\u00e9server un bloc m\u00e9moire destin\u00e9 \u00e0 recevoir la copie la cha\u00eene repr\u00e9sentant le nom du point.<\/li>\n<li>Recopier cette cha\u00eene dans ce bloc m\u00e9moire.<\/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\">iPoint* creePoint(double x, double y, const char* nom)\n{\n    iPoint* out = (iPoint*)malloc(sizeof(iPoint));\n    out-&gt;pt.x = x;\n    out-&gt;pt.y = y;\n    out-&gt;nom = (char*)malloc(1+(strlen(nom)*sizeof(char)));\n    strcpy(out-&gt;nom,nom);\n    return out;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez la fonction&#8230;<\/p>\n<pre><code class=\"language-C\">iPoint* clonePoint(iPoint* m);\n<\/code><\/pre>\n<p>&#8230;permettant de cloner l&rsquo;instance de <code>iPoint<\/code> d\u00e9sign\u00e9e par <code>m<\/code>. Comme il se doit pour un clone, l&rsquo;instance produite doit \u00eatre identique \u00e0 l&rsquo;originale mais compl\u00e8tement ind\u00e9pendante en m\u00e9moire. Vous devez utiliser la fonction <code>creePoint<\/code> afin de simplifier au maximum le code.<\/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\">iPoint* clonePoint(iPoint* m)\n{\n    iPoint* out = creePoint(m-&gt;pt.x, m-&gt;pt.y, m-&gt;nom);\n    return out;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez la fonction&#8230;<\/p>\n<pre><code class=\"language-C\">int compare(iPoint* p1, iPoint* p2);\n<\/code><\/pre>\n<p>&#8230;qui retourne vrai (1) si les coordonn\u00e9es des points d\u00e9sign\u00e9s par <code>p1<\/code> et <code>p2<\/code> sont identiques et faux (0) dans le cas contraire. Cette fonction de comparaison ne tient pas compte des noms des points.<\/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\">int compare(iPoint* p1, iPoint* p2)\n{\n    return (p1-&gt;pt.x == p2-&gt;pt.x) &amp;&amp; (p1-&gt;pt.y == p2-&gt;pt.y);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez la fonction&#8230;<\/p>\n<pre><code class=\"language-C\">void deletePoint(iPoint* p);\n<\/code><\/pre>\n<p>&#8230;qui lib\u00e8re toute la m\u00e9moire occup\u00e9e par l&rsquo;instance de <code>iPoint<\/code> (avec sa ramification) d\u00e9sign\u00e9e par <code>p<\/code>.<\/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 deletePoint(iPoint* p)\n{\n    free(p-&gt;nom);\n    free(p);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez la fonction&#8230;<\/p>\n<pre><code class=\"language-C\">void printIpoint(iPoint* p);\n<\/code><\/pre>\n<p>&#8230;qui affiche une instance de <code>iPoint<\/code> avec un format similaire \u00e0 l&rsquo;exemple suivant (le nom du point est entre crochets) :<\/p>\n<pre><code class=\"language-plain_text\">(3.00,5.00)[Point 1]\n<\/code><\/pre>\n<p>Cette fonction doit appeler la fonction&#8230;<\/p>\n<pre><code class=\"language-C\">void printPoint(point* p);\n<\/code><\/pre>\n<p>&#8230;qui affiche une instance de <code>point<\/code>.<\/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 printIpoint(iPoint* p)\n{\n    printPoint(&amp;(p-&gt;pt));\n    printf (\"[%s]\\n\", p-&gt;nom);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Donnez les lignes de code permettant de :<\/p>\n<ul>\n<li>Cr\u00e9er une instance de <code>iPoint<\/code> de coordonn\u00e9es \\((3.0,5.0)\\) et placer son adresse dans une variable <code>p1<\/code>.<\/li>\n<li>Cr\u00e9er un clone de cette instance et placer son adresse dans une variable <code>p2<\/code>.<\/li>\n<li>Comparer ces deux instances avec la fonction <code>compare<\/code> et afficher <code>OK<\/code> si les instances repr\u00e9sentent des points de m\u00eames coordonn\u00e9es.<\/li>\n<li>Afficher l&rsquo;instance d\u00e9sign\u00e9e par <code>p1<\/code> \u00e0 l&rsquo;aide de la fonction <code>printIpoint<\/code>.<\/li>\n<li>Lib\u00e9rer la m\u00e9moire occup\u00e9e par les deux instances de <code>iPoint<\/code>.<\/li>\n<\/ul>\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\">    iPoint* p1 = creePoint(3.0, 5.0, \"Point 1\");\n    iPoint* p2 = clonePoint(p1);\n    if(compare(p1,p2)) printf(\"OK\\n\");\n    printIpoint(p1);\n    deletePoint(p1);\n    deletePoint(p2);\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-f-ent1-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement F.ent1.3<\/h4>\n<p>Dans cet exercice, on utilise la structure date vue pr\u00e9c\u00e9demment :<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    char jour;\n    char mois;\n    int annee;\n}date;\n<\/code><\/pre>\n<p>La fonction suivante permet d&rsquo;afficher une instance de <code>date<\/code> :<\/p>\n<pre><code class=\"language-C\">void displayDate(date d)\n{\n    printf(\"%02d\/%02d\/%d \", d.jour, d.mois, d.annee);\n}\n<\/code><\/pre>\n<p>La structure suivante repr\u00e9sente une pile de dates :<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    int capa;\n    int top;\n    date* data;\n}pileDates;\n<\/code><\/pre>\n<p>Les champs ont les r\u00f4les suivants :<\/p>\n<ul>\n<li><code>capa<\/code> : capacit\u00e9 de la pile, i.e., nombre de dates pouvant \u00eatre empil\u00e9es.<\/li>\n<li><code>top<\/code> : sommet de la pile, i.e., indice de la premi\u00e8re case libre du tableau de stockage.<\/li>\n<li><code>data<\/code> : pointe le tableau de stockage dans lequel se trouvent les dates empil\u00e9es.<\/li>\n<\/ul>\n<p>Les fonctions permettant d&rsquo;exploiter cette structure de donn\u00e9e sont les suivantes :<\/p>\n<ul>\n<li><code>pileDates* creePileD(int capa)<\/code> : Cr\u00e9e une pile de date de capacit\u00e9 <code>capa<\/code>, situ\u00e9e enti\u00e8rement dans le tas.<\/li>\n<li><code>void deletePile(pileDates* p)<\/code> : Lib\u00e8re toute la m\u00e9moire utilis\u00e9e par la pile de dates d\u00e9sign\u00e9e par <code>p<\/code>.<\/li>\n<li><code>void push(pileDates* p, date d)<\/code> : Empile la date <code>d<\/code> dans la pile de dates d\u00e9sign\u00e9e par <code>p<\/code>. Si la pile est pleine, sa capacit\u00e9 est augment\u00e9e de 10.<\/li>\n<li><code>date pop(pileDates* p)<\/code> : D\u00e9pile une instance de <code>date<\/code> de la pile d\u00e9sign\u00e9e par <code>p<\/code>, dont la taille (mais pas la capacit\u00e9) diminue de 1. La pile est cens\u00e9e contenir au moins une date. Aucune v\u00e9rification n&rsquo;est faite.<\/li>\n<li><code>void pushJMA(pileDates* p, int j, int m, int a)<\/code> : Empile la date constitu\u00e9e du jour <code>j<\/code>, du mois <code>m<\/code> et de l&rsquo;ann\u00e9e <code>a<\/code> dans la pile d\u00e9sign\u00e9e par <code>p<\/code>.<\/li>\n<\/ul>\n<p>Commencez par d\u00e9finir la fonction <code>creePileD<\/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\">pileDates* creePileD(int capa)\n{\n    pileDates* out = (pileDates*)malloc(sizeof(pileDates));\n    \/\/ \u00c0 compl\u00e9ter\n    return out;\n}\n<\/code><\/pre>\n<p>Il reste \u00e0 initialiser les trois champs de l&rsquo;instance de structure <code>pileDate<\/code> point\u00e9e par out.<\/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\">pileDates* creePileD(int capa)\n{\n    pileDates* out = (pileDates*)malloc(sizeof(pileDates));\n    out-&gt;top =0;\n    out-&gt;capa = capa;\n    out-&gt;data = (date*)malloc(capa*sizeof(date));\n    return out;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez la fonction <code>deletePile<\/code>.<\/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 deletePile(pileDates* p)\n{\n    free(p-&gt;data);\n    free(p);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez la fonction <code>push<\/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\">void push(pileDates* p, date d)\n{\n    if(p-&gt;top == p-&gt;capa)\n    {\n        \/\/ \u00c0 compl\u00e9ter\n    }\n    p-&gt;data[p-&gt;top] = d;\n    p-&gt;top++;\n}\n<\/code><\/pre>\n<p>La partie \u00e0 compl\u00e9ter doit agrandir le tableau de stockage des dates empil\u00e9e en utilisant la fonction <code>realloc<\/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\">void push(pileDates* p, date d)\n{\n    if(p-&gt;top == p-&gt;capa)\n    {\n        p-&gt;capa = p-&gt;capa + 10;\n        p-&gt;data = realloc(p-&gt;data, p-&gt;capa*sizeof(date));\n    }\n    p-&gt;data[p-&gt;top] = d;\n    p-&gt;top++;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez la fonction <code>pop<\/code>.<\/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\">date pop(pileDates* p)\n{\n    p-&gt;top--;\n    return p-&gt;data[p-&gt;top];\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez la fonction <code>pushJMA<\/code> (en utilisant <code>push<\/code>).<\/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 pushJMA(pileDates* p, int j, int m, int a)\n{\n    date d = {j, m, a};\n    push(p, d);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Donnez les lignes de code permettant de :<\/p>\n<ul>\n<li>Cr\u00e9er une pile de dates point\u00e9e par une variable <code>pile<\/code>.<\/li>\n<li>Empiler deux dates (de votre choix) dans cette pile en utilisant la fonction <code>pushJMA<\/code>.<\/li>\n<li>D\u00e9piler une date, l&rsquo;afficher, puis d\u00e9piler l&rsquo;autre et l&rsquo;afficher.<\/li>\n<li>Lib\u00e9rer toute la m\u00e9moire occup\u00e9e dans le tas par la pile de date.<\/li>\n<\/ul>\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\">    pileDates* pile = creePileD(10);\n    pushJMA(pile, 1, 2, 1986);\n    pushJMA(pile, 14, 9, 1987);\n    date d = pop(pile);\n    displayDate(d);\n    d = pop(pile);\n    displayDate(d);\n    deletePile(pile);\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"it%C3%A9ration-f-ent2\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration F.ent2<\/h3>\n<h4><a id=\"exercice-d-entrainement-f-ent2-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement F.ent2.1<\/h4>\n<p>On d\u00e9finit la structure suivante ayant pour r\u00f4le d&rsquo;encapsuler des chaines de mani\u00e8re \u00e0 faciliter leur utilisation.<\/p>\n<pre><code class=\"language-C\">#define MAX_SIZE 100\n\ntypedef struct\n{\n    char data[MAX_SIZE+1];\n}eString;\n<\/code><\/pre>\n<p>Une instance de <code>eString<\/code> contient une cha\u00eene repr\u00e9sent\u00e9e de mani\u00e8re standard par une suite de caract\u00e8res suivie du marqueur de fin 0. Sa longueur maximum est d\u00e9finie par la constante <code>MAX_SIZE<\/code>.<\/p>\n<p>L&rsquo;int\u00e9r\u00eat d&rsquo;encapsuler un tableau dans une structure est que les instances d&rsquo;une telle structure peuvent \u00eatre pass\u00e9es en param\u00e8tres en copie \u00e0 des fonctions et retourn\u00e9es par des fonctions, ce que qui n&rsquo;est pas r\u00e9alisable directement avec des tableaux.<\/p>\n<p>Vous devez r\u00e9aliser une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">eString creeString(char* str)\n<\/code><\/pre>\n<p>&#8230;qui retourne une instance de <code>eString<\/code> contenant la cha\u00eene d\u00e9sign\u00e9e par le param\u00e8tre <code>str<\/code>.<\/p>\n<p>Par exemple, l&rsquo;ex\u00e9cution des lignes de code suivantes&#8230;<\/p>\n<pre><code class=\"language-C\">    eString s = creeString(\"Bonjour\");\n    printf(\"%s\\n\", s.data);\n<\/code><\/pre>\n<p>&#8230;doit produire l&rsquo;affichage :<\/p>\n<pre><code class=\"language-plain_text\">Bonjour\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\">eString creeString(char* str)\n{\n    eString out;\n    strcpy(out.data, str);\n    return out;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">eString concat(eString s1, eString s2);\n<\/code><\/pre>\n<p>&#8230;qui retourne une chaine encapsul\u00e9e contenant la concat\u00e9nation des deux chaines encapsul\u00e9es d\u00e9sign\u00e9e par <code>s1<\/code> et <code>s2<\/code>.<\/p>\n<p>Par exemple, l&rsquo;ex\u00e9cution des lignes de code suivantes&#8230;<\/p>\n<pre><code class=\"language-C\">    eString s = creeString(\"aaa\");\n    eString t = creeString(\"bbb\");\n    s = concat(s, t);\n    printf(\"%s %s\\n\", s.data, t.data);\n<\/code><\/pre>\n<p>&#8230;doit produire l&rsquo;affichage :<\/p>\n<pre><code class=\"language-C\">aaabbb bbb\n<\/code><\/pre>\n<p>On suppose que la taille du r\u00e9sultat de la concat\u00e9nation est inf\u00e9rieure ou \u00e9gale \u00e0 <code>MAX_SIZE<\/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\">eString concat(eString s1, eString s2)\n{\n    eString out;\n    \/\/ \u00c0 compl\u00e9ter\n    return out;\n}\n<\/code><\/pre>\n<p>Il reste \u00e0 copier la cha\u00eene contenue dans l&rsquo;instance de <code>eString<\/code> d\u00e9sign\u00e9e par <code>s1<\/code> dans celle d\u00e9sign\u00e9e par <code>out<\/code> (avec <code>strcpy<\/code>), puis de concat\u00e9ner \u00e0 cette cha\u00eene (avec <code>strcat<\/code>) la cha\u00eene contenue dans l&rsquo;instance de <code>eString<\/code> d\u00e9sign\u00e9e par <code>s2<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/9.png\" alt=\"image-20220209184311656\" \/><\/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\">eString concat(eString s1, eString s2)\n{\n    eString out;\n    strcpy(out.data,s1.data);\n    strcat(out.data,s2.data);\n    return out;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Dessinez la situation en m\u00e9moire \u00e0 l&rsquo;issue de l&rsquo;ex\u00e9cution des lignes de code suivantes :<\/p>\n<pre><code class=\"language-C\">    eString s = creeString(\"aaa\");\n    eString t = concat(s,s);\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><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/8.png\" alt=\"image-20220209170157484\" \/><\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-f-ent2-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement F.ent2.2<\/h4>\n<p>On reprend le concept de cha\u00eene encapsul\u00e9e dans une structure de l&rsquo;exercice pr\u00e9c\u00e9dent, mais avec une structure ramifi\u00e9e bas\u00e9e sur le type suivant :<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    char* data;\n}rString;\n<\/code><\/pre>\n<p>D\u00e9finissez la fonction&#8230;<\/p>\n<pre><code class=\"language-C\">rString* creeRstring(char* str);\n<\/code><\/pre>\n<p>&#8230; permettant de cr\u00e9er une instance de <code>rString<\/code> situ\u00e9e (avec sa ramification) enti\u00e8rement dans le tas et contenant une <strong>copie<\/strong> de la cha\u00eene d\u00e9sign\u00e9e par le param\u00e8tre <code>str<\/code>.<\/p>\n<p>Par exemple, la ligne de code&#8230;<\/p>\n<pre><code class=\"language-C\">rString* s1 = creeRstring(\"abc\");\n<\/code><\/pre>\n<p>&#8230;doit produire la situation en m\u00e9moire suivante :<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/10.png\" alt=\"image-20220209191429882\" \/><\/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\">rString* creeRstring(char* str)\n{\n    rString* out = (rString*)malloc(sizeof(rString));\n    \/\/ \u00c0 compl\u00e9ter\n    return out;\n}\n<\/code><\/pre>\n<p>Il reste \u00e0 :<\/p>\n<ul>\n<li>R\u00e9server le bloc m\u00e9moire pour stocker la cha\u00eene qui sera point\u00e9e par le champ <code>data<\/code>.<\/li>\n<li>Recopier la cha\u00eenes d\u00e9sign\u00e9e par str dans ce bloc m\u00e9moire.<\/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\">rString* creeRstring(char* str)\n{\n    rString* out = (rString*)malloc(sizeof(rString));\n    out-&gt;data = (char*)malloc(1+(sizeof(char)*strlen(str)));\n    strcpy(out-&gt;data, str);\n    return out;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez une fonction&#8230;<\/p>\n<pre><code class=\"language-C\">rString* concatR(rString* s1, rString* s2);\n<\/code><\/pre>\n<p>&#8230;qui produit une nouvelle cha\u00eene encapsul\u00e9e repr\u00e9sentant la concat\u00e9nation de contenus des chap\u00eenes encapsul\u00e9es d\u00e9sign\u00e9es par <code>s1<\/code> et <code>s2<\/code>. La cha\u00eene encapsul\u00e9e produite ne doit \u00eatre compl\u00e8tement ind\u00e9pendante en m\u00e9moire des cha\u00eenes encapsul\u00e9es d\u00e9sign\u00e9es par <code>s1<\/code> et <code>s2<\/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\">rString* concatR(rString* s1, rString* s2)\n{\n    rString* out = (rString*)malloc(sizeof(rString));\n    int n = (int)strlen(s1-&gt;data) + (int)strlen(s2-&gt;data) +1;\n    \/\/ \u00c0 compl\u00e9ter\n    return out;\n}\n<\/code><\/pre>\n<p>Il manque :<\/p>\n<ul>\n<li>La r\u00e9servation du bloc m\u00e9moire permettant de stocker les caract\u00e8res de la cha\u00eene \u00e0 produire.<\/li>\n<li>La copie dans ce bloc du contenu de la cha\u00eene encapsul\u00e9e d\u00e9sign\u00e9e par <code>s1<\/code>.<\/li>\n<li>La concat\u00e9nation dans ce m\u00eame bloc du contenu de la cha\u00eene d\u00e9sign\u00e9e par <code>s2<\/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\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">rString* concatR(rString* s1, rString* s2)\n{\n    rString* out = (rString*)malloc(sizeof(rString));\n    int n = (int)strlen(s1-&gt;data) + (int)strlen(s2-&gt;data) +1;\n    out-&gt;data = (char*)malloc(1+(sizeof(char)*n));\n    strcpy(out-&gt;data, s1-&gt;data);\n    strcat(out-&gt;data, s2-&gt;data);\n    return out;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez la fonction&#8230;<\/p>\n<pre><code class=\"language-C\">void deleteRstring(rString* t);\n<\/code><\/pre>\n<p>&#8230;permettant de lib\u00e9rer la m\u00e9moire occup\u00e9e dans le tas par une instance de <code>rString<\/code> avec sa ramification.<\/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 deleteRstring(rString* t)\n{\n    free(t-&gt;data);\n    free(t);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Quand on ex\u00e9cute la fonction de test suivante&#8230;<\/p>\n<pre><code class=\"language-C\">void test(void)\n{\n    rString* s1 = creeRstring(\"abc\");\n    rString* s2 = concatR(s1, creeRstring(\"def\"));\n    printf(\"%s\\n\", s2-&gt;data);\n    deleteRstring(s1);\n    deleteRstring(s2);\n}\n<\/code><\/pre>\n<p>&#8230; on obtient l&rsquo;affichage :<\/p>\n<pre><code class=\"language-plain_text\">abcdef\n<\/code><\/pre>\n<p>L&rsquo;ex\u00e9cution se passe sans encombre, et pourtant il y a une erreur dans cette fonction. Trouvez-l\u00e0 et proposez une version corrig\u00e9e.<\/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>Lors le l&rsquo;ex\u00e9cution de cette fonction, il y a deux appels \u00e0 <code>creeRstring<\/code> et un appel \u00e0 <code>concatR<\/code>. Au total, combien de blocs m\u00e9moire sont r\u00e9serv\u00e9s par ces appels ? Combien sont lib\u00e9r\u00e9s ?<\/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>Les blocs m\u00e9moire constituant l&rsquo;instance ramifi\u00e9e produite par le deuxi\u00e8me appel de <code>creeRstring<\/code> ne sont jamais lib\u00e9r\u00e9s. Il y a donc une fuite m\u00e9moire. Trouvez un moyen de l&rsquo;\u00e9viter.<\/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 test9(void)\n{\n    rString* s1 = creeRstring(\"abc\");\n    rString* tmp = creeRstring(\"def\");\n    rString* s2 = concatR(s1, tmp);\n    deleteRstring(tmp);\n    printf(\"%s\\n\", s2-&gt;data);\n    deleteRstring(s1);\n    deleteRstring(s2);\n}\n<\/code><\/pre>\n<p>Ce type de probl\u00e8me ne se pose pas avec la version monolithique des cha\u00eenes encapsul\u00e9es de l&rsquo;exercice pr\u00e9c\u00e9dent, mais ces cha\u00eenes gaspillent de la m\u00e9moire et sont limit\u00e9es en longueur. Pour trouver une solution cumulant les avantages des structures monolithiques et des structures ramifi\u00e9es, il faudra utiliser le langage C++.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-f-ent2-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement F.ent2.3<\/h4>\n<p>Dans cet exercice, nous allons impl\u00e9menter une pile de chaines de caract\u00e8res situ\u00e9e compl\u00e8tement dans le tas et repr\u00e9sent\u00e9e par la structure suivante :<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    int capa;\n    int top;\n    char** tab;\n}pString;\n<\/code><\/pre>\n<p>Pour bien comprendre de quoi nous parlons, observons la repr\u00e9sentation en m\u00e9moire d&rsquo;une pile contenant les cha\u00eenes \u00ab\u00a0Tim\u00a0\u00bb et \u00ab\u00a0Tom\u00a0\u00bb.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/14.png\" alt=\"image-20220210230118264\" \/><\/p>\n<p>Les r\u00f4les des champs de la structure sont les suivants :<\/p>\n<ul>\n<li><code>capa<\/code> : Capacit\u00e9 du tableau de stockage, c&rsquo;est \u00e0 dire nombre maximum de cha\u00eenes pouvant \u00eatre simultan\u00e9ment dans la pile. Cette valeur pourra augmenter en cas de besoin.<\/li>\n<li><code>top<\/code> : Sommet de la pile, c&rsquo;est \u00e0 dire l&rsquo;indice de la case du tableau de stockage o\u00f9 sera plac\u00e9e l&rsquo;adresse de la procha\u00eene cha\u00eene empil\u00e9e.<\/li>\n<li><code>tab<\/code> : Tableau de stockage des adresses des cha\u00eenes empil\u00e9es. Chacune des cellules d&rsquo;indice 0 \u00e0 <code>top-1<\/code> contient un pointeur d\u00e9signant un bloc m\u00e9moire situ\u00e9 dans le tas contenant une cha\u00eene de caract\u00e8res.<\/li>\n<\/ul>\n<p>Voici les fonctions \u00e0 impl\u00e9menter :<\/p>\n<ul>\n<li><code>pString* creePstring(int capa)<\/code> : Cr\u00e9e une pile vide avec un tableau de stockage de capacit\u00e9 <code>capa<\/code>. Le tableau de stockage est un tableau de <code>char*<\/code> non initialis\u00e9.<\/li>\n<li><code>void delPstring(pString* p)<\/code> : Lib\u00e8re toute la m\u00e9oire occup\u00e9e par la pile d\u00e9sign\u00e9es par <code>p<\/code>, y compris celle utilis\u00e9e pour le stockage des cha\u00eenes encore empil\u00e9es.<\/li>\n<li><code>void pushPstring(pString* p, const char* s)<\/code> : Empile dans la pile d\u00e9sign\u00e9e par <code>p<\/code> une <strong>copie<\/strong> de la cha\u00eene d\u00e9sign\u00e9e par <code>s<\/code>.<\/li>\n<li><code>void popPstring(pString* p, char* dest)<\/code> : Retire de la pile d\u00e9sign\u00e9e par <code>p<\/code> la derni\u00e8re cha\u00eene empil\u00e9e (la plus r\u00e9cente) et la copie dans le tableau d\u00e9sign\u00e9 par <code>dest<\/code>, qui est suppos\u00e9 avoir une taille suffisante.<\/li>\n<\/ul>\n<p>Vous devez d&rsquo;abord d\u00e9finir la fonction <code>creePstring<\/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\">pString* creePstring(int capa)\n{\n    pString* out = (pString*)malloc(sizeof(pString));\n    \/\/ \u00c0 compl\u00e9ter\n    return out;\n}\n<\/code><\/pre>\n<p>Il reste \u00e0 ajouter :<\/p>\n<ul>\n<li>L&rsquo;initialisation du champ <code>capa<\/code>.<\/li>\n<li>L&rsquo;initialisation du champ <code>top<\/code>.<\/li>\n<li>La cr\u00e9ation du tableau de stockage dont l&rsquo;adresse doit \u00eatre plac\u00e9ec dans le champ <code>tab<\/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\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">pString* creePstring(int capa)\n{\n    pString* out = (pString*)malloc(sizeof(pString));\n    out-&gt;capa = capa;\n    out-&gt;top = 0;\n    out-&gt;tab = (char**)malloc(capa*sizeof(char*));\n    return out;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Donnez la d\u00e9finition de la fonction <code>delPstring<\/code>. Attention, le nombre de blocs m\u00e9moire \u00e0 lib\u00e9rer d\u00e9pend du nombre de cha\u00eenes encore empil\u00e9es.<\/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 delPstring(pString* p)\n{\n    for(int i=0; i&lt;p-&gt;top; i++)\n    {\n        \/\/ \u00c0 compl\u00e9ter\n    }\n    free(p-&gt;tab);\n    free(p);\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 delPstring(pString* p)\n{\n    for(int i=0; i&lt;p-&gt;top; i++)\n    {\n        free(p-&gt;tab[i]);\n    }\n    free(p-&gt;tab);\n    free(p);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>D\u00e9finissez la fonction <code>pushPstring<\/code>. Si la pile est remplie, sa capacit\u00e9 doit \u00eatre augment\u00e9e. La fonction <code>realloc<\/code> est votre amie.<\/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 pushPstring(pString* p, const char* s)\n{\n    if(p-&gt;top == p-&gt;capa)\n    {\n        p-&gt;capa = p-&gt;capa + 10;\n        p-&gt;tab = (char**)realloc(p-&gt;tab, p-&gt;capa*sizeof(char*));\n    }\n    \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\n<p>Il faut pr\u00eater attention au fait que le tableau de stockage est un tableau de pointeurs sur des caract\u00e8res et donc que la taille de chaque cellule est <code>sizeof(char*)<\/code>.<\/p>\n<p>Il reste \u00e0 :<\/p>\n<ul>\n<li>Cr\u00e9er dans le tas le tableaux de caract\u00e8re qui contiendra la copie de la cha\u00eene \u00e0 empiler.<\/li>\n<li>Copier la cha\u00eene \u00e0 empiler dans ce tableau.<\/li>\n<li>Mettre \u00e0 jour les valeurs des champs tab et top.<\/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 pushPstring(pString* p, const char* s)\n{\n    if(p-&gt;top == p-&gt;capa)\n    {\n        p-&gt;capa = p-&gt;capa + 10;\n        p-&gt;tab = (char**)realloc(p-&gt;tab, p-&gt;capa*sizeof(char*));\n    }\n    int n = strlen(s) + 1;\n    p-&gt;tab[p-&gt;top] = (char*)malloc(n * sizeof(char));\n    strcpy(p-&gt;tab[p-&gt;top], s);\n    p-&gt;top++;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Vous devez d\u00e9finir la fonction <code>popPstring<\/code>. Dans le cas o\u00f9 la pile est vide, la fonction doit afficher un message d&rsquo;erreur et provoquer un arr\u00eat du programme par appel de <code>exit(1)<\/code>. Attention de ne pas provoquer des fuites m\u00e9moire.<\/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 popPstring(pString* p, char* dest)\n{\n    p-&gt;top = p-&gt;top - 1;\n    if(p-&gt;top &lt; 0)\n    {\n        printf(\"Erreur : pile vide\\n\");\n        exit(1);\n    }\n    \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\n<p>Il reste \u00e0 recopier dans le tableau point\u00e9 par <code>dest<\/code> le contenu de la cha\u00eene \u00e0 d\u00e9piler, puis \u00e0 lib\u00e9rer la m\u00e9moire occup\u00e9e dans le tas par cette cha\u00eene pour \u00e9viter une fuite m\u00e9moire.<\/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 popPstring(pString* p, char* dest)\n{\n    p-&gt;top = p-&gt;top - 1;\n    if(p-&gt;top &lt; 0)\n    {\n        printf(\"Erreur : pile vide\\n\");\n        exit(1);\n    }\n    strcpy(dest,p-&gt;tab[p-&gt;top]);\n    free(p-&gt;tab[p-&gt;top]);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Vous devez donner les lignes de code permettant de :<\/p>\n<ul>\n<li>Cr\u00e9er une pile de chapines de capacit\u00e9 10 d\u00e9sign\u00e9e par une variable <code>pile<\/code>.<\/li>\n<li>Empiler les cha\u00eenes <code>\"Tim\"<\/code> et <code>\"Tom\"<\/code>.<\/li>\n<li>D\u00e9piler et afficher une cha\u00eene.<\/li>\n<li>D\u00e9piler \u00e0 nouveau une cha\u00eene et l&rsquo;afficher.<\/li>\n<li>Lib\u00e9rer toute la m\u00e9moire occup\u00e9e dans le tas.<\/li>\n<\/ul>\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\">    pString* pile = creePstring(10);\n    pushPstring(pile, \"Tim\");\n    pushPstring(pile, \"Tom\");\n    char buf[100];\n    popPstring(pile, buf);\n    printf(\"%s\\n\", buf);\n    popPstring(pile, buf);    \n    printf(\"%s\\n\", buf);\n    delPstring(pile);\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p>Pour r\u00e9cup\u00e9rer les contenus des cha\u00eenes d\u00e9pil\u00e9es, il a \u00e9t\u00e9 n\u00e9cessaire de cr\u00e9er un tableau de destination qui a \u00e9t\u00e9 appel\u00e9 <code>buf<\/code>.<\/p>\n<hr \/>\n<h2><a id=\"activit%C3%A9-de-consolidation-f-top\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 de consolidation F.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>Le but de cet exercice est de r\u00e9soudre un probl\u00e8me c\u00e9l\u00e8bre : r\u00e9ussir \u00e0 placer &#40;n&#41; reines sur un \u00e9chiquier de &#40;n \\times n&#41; sans que plus d&rsquo;une reine se trouve sur une m\u00eame ligne, une m\u00eame colonne ou une m\u00eame diagonale.<\/p>\n<p>Voici une solutions pour &#40;n=8&#41;, parmi 92 possibles. Les diagonales ont \u00e9t\u00e9 trac\u00e9es pour permettre une v\u00e9rification visuelle.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/11.png\" alt=\"image-20220210191634381\" \/><\/p>\n<p>Il existe un algorithme produisant une solution particuli\u00e8re pour chaque valeur de &#40;n&#41;, mais dans cet exercice nous utiliserons un proc\u00e9d\u00e9 appel\u00e9 recherche locale stochastique qui peut produire n&rsquo;importe quelle solution par petites modifications al\u00e9atoires et s\u00e9lections \u00e0 partir d&rsquo;une configuration initiale al\u00e9atoire.<\/p>\n<p>Nous allons commencer par repr\u00e9senter une configuration des &#40;n&#41; reines sur un \u00e9chiquier de &#40;n&#41; lignes et &#40;n&#41; colonnes. Pour limiter l&rsquo;ensemble des configurations \u00e0 explorer, appel\u00e9 espace de recherche, nous consid\u00e9rerons uniquement les configurations dans lesquelles il y a exactement une reine sur chaque ligne et chaque colonne. Ces configurations peuvent \u00eatre repr\u00e9sent\u00e9es par des permutations, en l&rsquo;occurrence des listes d&rsquo;entier tous diff\u00e9rents compris entre 0 et &#40;n-1&#41;.<\/p>\n<p>Par exemple, la configuration suivante&#8230;<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/12.png\" alt=\"image-20220210192732009\" \/><\/p>\n<p>&#8230;se repr\u00e9sente par la permutation &#40;(6,3,1,7,5,0,2,4)&#41;. La premi\u00e8re valeur repr\u00e9sente la colonne sur laquelle se trouve la reine de la ligne 0, la deuxi\u00e8me repr\u00e9sente la colonne de la reine situ\u00e9e en ligne 1, etc.<\/p>\n<p>Toutes les permutations ne repr\u00e9sentent pas des solutions. Seulement un tr\u00e8s petit nombre d&rsquo;entre elles le sont. Mais toutes les solutions sont repr\u00e9sentables par des permutations.<\/p>\n<p>Une configuration sera repr\u00e9sent\u00e9e par la structure suivante&#8230;<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    int n;\n    int* tab;\n}config;\n<\/code><\/pre>\n<p>&#8230;dans laquelle le champ <code>n<\/code> repr\u00e9sente la taille de l&rsquo;\u00e9chiquier et le champ <code>tab<\/code> pointe un tableau dynamique contenant les valeurs de la permutation repr\u00e9sentant les positions des reines.<\/p>\n<p>Votre premi\u00e8re mission consiste \u00e0 impl\u00e9menter les fonctions suivantes :<\/p>\n<ul>\n<li><code>config* newConfig(int n)<\/code> : cr\u00e9e une instance de <code>config<\/code> situ\u00e9e dans le tas, incluant le tableau destin\u00e9 \u00e0 recevoir les positions des reines. Le tableau n&rsquo;est pas initialis\u00e9.<\/li>\n<li><code>void delConfig(config* c)<\/code> : lib\u00e8re la m\u00e9moire occup\u00e9e par une configuration cr\u00e9\u00e9e ant\u00e9rieurement par un appel \u00e0 <code>newConfig<\/code>.<\/li>\n<\/ul>\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\">config* newConfig(int n)\n{\n    config* out = (config*)malloc(sizeof(config));\n    out-&gt;n = n;\n    out-&gt;tab = (int*)malloc(n*sizeof(int));\n    return out;\n}\n\nvoid delConfig(config* c)\n{\n    free(c-&gt;tab);\n    free(c);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Vous devez maintenant d\u00e9finir les fonctions suivantes :<\/p>\n<ul>\n<li><code>void randConfig(config* c)<\/code> : place dans l&rsquo;instance de <code>config<\/code> point\u00e9e par <code>c<\/code> une configuration al\u00e9atoire. Attention, cette configuration doit comporter exactement une reine par ligne et par colonne, donc \u00eatre repr\u00e9sent\u00e9e par une permutation. Tentez de trouver un algorithme efficace pour produire une permutation al\u00e9atoire.<\/li>\n<li><code>void printConfig(config* c)<\/code> : affiche \u00e0 l&rsquo;\u00e9cran la configuration d\u00e9sign\u00e9e par le param\u00e8tre <code>c<\/code>.<\/li>\n<\/ul>\n<p>Commencez par d\u00e9finir <code>printConfig<\/code>.<\/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 printConfig(config* c)\n{\n    for(int i=0; i&lt;c-&gt;n; i++)\n    {\n        for(int j=0; j&lt;c-&gt;n; j++)\n        {\n            if(j==c-&gt;tab[i])\n                printf(\"O \");\n            else\n                printf(\"- \");\n        }\n        printf(\"\\n\");\n    }\n}\n<\/code><\/pre>\n<p>Le code dans la boucle <code>for<\/code> est d\u00e9coule du fait que la reine situ\u00e9e sur la ligne <code>i<\/code> se trouve sur la colonne <code>c-&gt;tab[i]<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Ensuite d\u00e9finissez la fonction <code>randConfig<\/code>. Produire une efficacement une permutation al\u00e9atoire n\u00e9cessite une r\u00e9flexion algorithmique.<\/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>Vous pouvez utiliser le principe suivant :<\/p>\n<ol>\n<li>Produire la permutation \\((0,1,2,\\dots, n-1)\\).<\/li>\n<li>\u00c9changer la valeur situ\u00e9e \u00e0 chaque position avec une valeur situ\u00e9e \u00e0 une position tir\u00e9e au hasard.<\/li>\n<\/ol>\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 randConfig(config* c)\n{\n    for(int i=0; i&lt;c-&gt;n; i++)\n    {\n        c-&gt;tab[i] = i;\n    }\n    for(int i=0; i&lt;c-&gt;n-1; i++)\n    {\n        int pos = rand()%c-&gt;n;\n        int tmp = c-&gt;tab[i];\n        c-&gt;tab[i] = c-&gt;tab[pos];\n        c-&gt;tab[pos] = tmp;\n    }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>\u00c0 pr\u00e9sent, vous devez d\u00e9finir une fonction permettant de r\u00e9aliser une petite modification al\u00e9atoire d&rsquo;une configuration et une fonction permettant d&rsquo;annuler cette modification. Une modification consiste \u00e0 \u00e9changer deux valeurs de la permutation situ\u00e9es \u00e0 des positions choisies au hasard. Pour pouvoir annuler une modification, on stocke les positions des valeurs \u00e9chang\u00e9es dans une instance de la structure suivante :<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    int p1;\n    int p2;\n}modif;\n<\/code><\/pre>\n<p>Les deux fonctions \u00e0 d\u00e9finir sont :<\/p>\n<ul>\n<li><code>void changeConfig(config* c, modif* mod)<\/code> : R\u00e9alise un \u00e9change de deux valeurs tir\u00e9es au hasard dans la permutation repr\u00e9sentant la configuration d\u00e9sign\u00e9e par <code>c<\/code> et place dans l&rsquo;instance de <code>modif<\/code> d\u00e9sign\u00e9e par <code>mod<\/code> les positions \u00e9chang\u00e9es.<\/li>\n<li><code>void restoreConfig(config* c, const modif* mod<\/code>) : R\u00e9alise dans la configuration d\u00e9sign\u00e9e par <code>c<\/code> l&rsquo;\u00e9change des deux valeurs situ\u00e9es aux positions m\u00e9moris\u00e9es dans l&rsquo;instance de <code>modif<\/code> d\u00e9sign\u00e9e par <code>mod<\/code>.<\/li>\n<\/ul>\n<p>Commencez par d\u00e9finir <code>changeConfig<\/code>.<\/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 changeConfig(config* c, modif* mod)\n{\n    mod-&gt;p1 = rand()%c-&gt;n;\n    mod-&gt;p2 = rand()%c-&gt;n;\n    int tmp = c-&gt;tab[mod-&gt;p1];\n    c-&gt;tab[mod-&gt;p1] = c-&gt;tab[mod-&gt;p2];\n    c-&gt;tab[mod-&gt;p2] = tmp;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p>Puis d\u00e9finissez la fonction <code>restoreConfig<\/code>.<\/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 restoreConfig(config* c, const modif* mod)\n{\n    int tmp = c-&gt;tab[mod-&gt;p1];\n    c-&gt;tab[mod-&gt;p1] = c-&gt;tab[mod-&gt;p2];\n    c-&gt;tab[mod-&gt;p2] = tmp;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Pour faire fonctionner notre algorithme de recherche, nous avons besoin de calculer un score qui mesure la qualit\u00e9 d&rsquo;une configuration. Ce score doit \u00eatre \u00e9gal \u00e0 0 pour les solutions et doit avoir une valeur \u00e9lev\u00e9e quand beaucoup de reines sont align\u00e9es avec d&rsquo;autres sur des diagonales.<\/p>\n<p>Le principe que nous utiliserons est le suivant : on comptabilise le nombre de reines \u00ab\u00a0en trop\u00a0\u00bb sur chacune des diagonales et on ajoute les valeurs obtenues. Par exemple, si une diagonale comporte 3 reines, il y a deux reines en trop, donc on ajoute 2 au score.<\/p>\n<p>Pour calculer ce score efficacement, en parcourant une seule fois la permutation repr\u00e9sentant la configuration \u00e0 \u00e9valuer, nous allons utiliser un algorithme astucieux bas\u00e9 sur la num\u00e9rotation des diagonales montantes et descendantes illustr\u00e9e ci-dessous :<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/13.png\" alt=\"image-20220210204402371\" \/><\/p>\n<p>Les diagonales montantes sont num\u00e9rot\u00e9es de 0 \u00e0 &#40;2n-2&#41; et les diagonales descendantes aussi. Une case situ\u00e9e en ligne &#40;i&#41; et en colonne &#40;j&#41; appartient :<\/p>\n<ul>\n<li>\u00e0 la diagonale montante num\u00e9rot\u00e9 \\(i+j\\),<\/li>\n<li>et \u00e0 la diagonale descendantes num\u00e9rot\u00e9e \\(n-1-i+j\\).<\/li>\n<\/ul>\n<p>Pour compter efficacement les reines plac\u00e9es sur chaque diagonale, nous utiliserons la structure suivante :<\/p>\n<pre><code class=\"language-C\">typedef struct\n{\n    int n;\n    int* cptDM;\n    int* cptDD;\n}errCount;\n<\/code><\/pre>\n<p>Voici les r\u00f4les des champs de cette structure :<\/p>\n<ul>\n<li><code>n<\/code> : Nombres de cases dans les lignes et colonnes (utile pour calculer les num\u00e9ros des diagonales).<\/li>\n<li><code>cptDM<\/code> : pointe un tableau dynamique de <code>2n-1<\/code> cellules contenant chacune un entier.<\/li>\n<li><code>cptDD<\/code> : pointe un tableau dynamique de <code>2n-1<\/code> cellules contenant chacune un entier.<\/li>\n<\/ul>\n<p>Chaque cellule <code>cptDM[i]<\/code> servira \u00e0 compter le nombre de reines sur la diagonale montante num\u00e9ro <code>i<\/code> (pour <code>i<\/code> compris entre 0 et <code>2n-2<\/code>). Les cellules du tableau point\u00e9 par <code>cptDD<\/code> auront le m\u00eame usage pour les diagonales descendantes.<\/p>\n<p>Le calcul du score se fait en mettant \u00e0 0 toutes les cellules des tableaux d\u00e9sign\u00e9s par les champs <code>cptDM<\/code> et <code>cptDD<\/code>, puis en parcourant une seule fois toutes les positions occup\u00e9es par une reine, \u00e0 incr\u00e9menter <code>cptDM[i]<\/code> \u00e0 chaque fois qu&rsquo;une reine est sur la diagonale montante <code>i<\/code> et \u00e0 incr\u00e9menter <code>cptDD[i]<\/code> \u00e0 chaque fois qu&rsquo;une reine est sur la diagonale descendante <code>i<\/code>.<\/p>\n<p>Les informations recueillies dans ces tableaux permettent de d\u00e9terminer le score de la configuration \u00e9valu\u00e9e.<\/p>\n<p>Il faut commencer par d\u00e9finir les fonctions permettant de cr\u00e9er dans le tas une instance de <code>errCount<\/code> et de la d\u00e9truire ult\u00e9rieurement.<\/p>\n<ul>\n<li><code>errCount* newErrCount(int n)<\/code> : Cr\u00e9e une instance de <code>errCount<\/code> (avec sa ramification) dans le tas.<\/li>\n<li><code>void delErrCount(errCount* e)<\/code> : Lib\u00e8re la m\u00e9moire occup\u00e9e par une instance de <code>errCout<\/code>.<\/li>\n<\/ul>\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\">errCount* newErrCount(int n)\n{\n    errCount* out = (errCount*)malloc(sizeof(errCount));\n    out-&gt;n = n;\n    out-&gt;cptDM = (int*)calloc((2*n)-1, sizeof(int));\n    out-&gt;cptDD = (int*)calloc((2*n)-1, sizeof(int));\n    return out;\n}\n\nvoid delErrCount(errCount* e)\n{\n    free(e-&gt;cptDM);\n    free(e-&gt;cptDD);\n    free(e);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Vous devez \u00e0 pr\u00e9sent d\u00e9finir la fonction <code>void razErrCount(errCount* e)<\/code> qui remet \u00e0 0 les cellules des deux tableaux de l&rsquo;instance de <code>errCount<\/code> d\u00e9sign\u00e9e par le param\u00e8tre <code>e<\/code>.<\/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 razErrCount(errCount* e)\n{\n    for(int i=0; i&lt;(2*e-&gt;n)-1; i++)\n    {\n        e-&gt;cptDM[i] = 0;\n        e-&gt;cptDD[i] = 0;\n    }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Vous devez d\u00e9finir la fonction <code>int getScore(config* c, errCount* e)<\/code> qui calcule le score de la configuration d\u00e9sign\u00e9e par <code>c<\/code> en utilisant l&rsquo;instance de <code>errCount<\/code> d\u00e9sign\u00e9e par <code>e<\/code> pour le comptage des reines dans les diagonales. Cette instance de <code>errCount<\/code> est cr\u00e9\u00e9e une seule fois et sert \u00e0 chaque nouveau calcul de score pour des raisons d&rsquo;efficacit\u00e9. Ce choix de conception est justifi\u00e9 par le fait que la cr\u00e9ation et la destruction d&rsquo;une instance de classe ramifi\u00e9e a un certain co\u00fbt en temps d&rsquo;ex\u00e9cution.<\/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\">int getScore(config* c, errCount* e)\n{\n    razErrCount(e);\n    for(int i=0; i&lt;c-&gt;n; i++)\n    {\n        int j = c-&gt;tab[i];\n        e-&gt;cptDM[i+j]++;\n        e-&gt;cptDD[c-&gt;n-1-i+j]++;\n    }\n    int score = 0;\n    \/\/ \u00c0 compl\u00e9ter\n    return score;\n}\n<\/code><\/pre>\n<p>La premi\u00e8re partie donn\u00e9e ici permet de compter les reines situ\u00e9es sur chaque diagonale montante et chaque diagonale descendante.<\/p>\n<p>Il reste \u00e0 exploiter les informations obtenues pour calculer le score.<\/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 getScore(config* c, errCount* e)\n{\n    razErrCount(e);\n    for(int i=0; i&lt;c-&gt;n; i++)\n    {\n        int j = c-&gt;tab[i];\n        e-&gt;cptDM[i+j]++;\n        e-&gt;cptDD[c-&gt;n-1-i+j]++;\n    }\n    int score = 0;\n    for(int i=0; i&lt;(2*e-&gt;n)-1; i++)\n    {\n        if(e-&gt;cptDM[i]&gt;1) score += (e-&gt;cptDM[i]-1);\n        if(e-&gt;cptDD[i]&gt;1) score += (e-&gt;cptDD[i]-1);\n    }\n    return score;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Il reste \u00e0 d\u00e9finir la fonction <code>config* searchSol(int n, int maxTries)<\/code> qui recherche une solution du probl\u00e8me des <code>n<\/code> reines en faisant \u00e9voluer une configuration appel\u00e9e configuration courante jusqu&rsquo;\u00e0 ce obtenir une solution ou d\u00e9passer <code>maxTries<\/code> \u00e9tapes. Dans le cas o\u00f9 aucune solution n&rsquo;est trouv\u00e9e, la fonction doit retourner la valeur <code>NULL<\/code>.<\/p>\n<ol>\n<li>On produit une configuration al\u00e9atoire, qui est la premi\u00e8re version de la configuration courante, et on calcule son score.<\/li>\n<li>\u00c0 chaque nouvelle it\u00e9ration, on r\u00e9alise une petite modification al\u00e9atoire de la configuration courante et on calcule sons score. Si le nouveau score est plus \u00e9lev\u00e9 que l&rsquo;ancien, on annule la modification, sinon on conserve la modification.<\/li>\n<\/ol>\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\">config* searchSol(int n, int maxTries)\n{\n    config* conf = newConfig(n);\n    randConfig(conf);\n    modif mod;\n    errCount* err = newErrCount(n);\n    int score = getScore(conf,err);\n    for(int i=0; i&lt;maxTries; i++)\n    {\n        \/\/ \u00c0 compl\u00e9ter\n    }\n    return NULL;\n}\n<\/code><\/pre>\n<p>Nous avons ici les initialisations des donn\u00e9es, la production de la premi\u00e8re version de la configuration courante et le calcul de son score.<\/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\">config* searchSol(int n, int maxTries)\n{\n    config* conf = newConfig(n);\n    randConfig(conf);\n    modif mod;\n    errCount* err = newErrCount(n);\n    int score = getScore(conf,err);\n    for(int i=0; i&lt;maxTries; i++)\n    {       \n        changeConfig(conf, &amp;mod);\n        int newScore = getScore(conf,err);\n        if(newScore&gt;score)\n        {\n            \/\/ \u00c0 compl\u00e9ter\n        }\n        else if(newScore==0)\n        {\n            \/\/ \u00c0 compl\u00e9ter\n        }\n        else\n        {\n            score = newScore;\n        }\n    }\n    return NULL;\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\">config* searchSol(int n, int maxTries)\n{\n    config* conf = newConfig(n);\n    randConfig(conf);\n    modif mod;\n    errCount* err = newErrCount(n);\n    int score = getScore(conf,err);\n    for(int i=0; i&lt;maxTries; i++)\n    {       \n        changeConfig(conf, &amp;mod);\n        int newScore = getScore(conf,err);\n        if(newScore&gt;score)\n        {\n            restoreConfig(conf,&amp;mod);\n        }\n        else if(newScore==0)\n        {\n            delErrCount(err);\n            return conf;\n        }\n        else\n        {\n            score = newScore;\n        }\n    }\n    return NULL;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>La fonction <code>main<\/code> suivante permet de tester la fonction de recherche d&rsquo;une solution. \u00c0 essayer avec diff\u00e9rentes valeurs de &#40;n&#41; et du nombre maximum d&rsquo;\u00e9tapes de recherche.<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    srand(time(NULL));\n    config* sol = searchSol(8, 1000);\n    if(sol==NULL)\n    {\n        printf(\"Aucune solution trouv\u00e9e\\n\");\n    }\n    else\n    {\n        printConfig(sol);\n        delConfig(sol);\n    }   \n    return 0;\n}\n<\/code><\/pre>\n<p>Voici un exemple de solution pour &#40;n=30&#41; trouv\u00e9 \u00ab\u00a0instantan\u00e9ment\u00a0\u00bb par le programme :<\/p>\n<pre><code class=\"language-plain_text\">- - - - - - - - - - - - O - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - - - - - - - - O - - \n- - - - - - O - - - - - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - O - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - O - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - - - - - O - - - - - \n- - - - - - - - - - - - - - - O - - - - - - - - - - - - - - \nO - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n- - - O - - - - - - - - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - O - - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - O - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - - - - - - O - - - - \n- - - - - - - - O - - - - - - - - - - - - - - - - - - - - - \n- - O - - - - - - - - - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - O - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - - - - - - - O - - - \n- - - - - - - - - - O - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - - - - O - - - - - - \n- - - - - - - - - - - - - - - - - - - - - O - - - - - - - - \n- - - - O - - - - - - - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - - - - - - - - - O - \n- - - - - - - - - - - O - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - O - - - - - - - - - - - - - - - - \n- - - - - - - O - - - - - - - - - - - - - - - - - - - - - - \n- O - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - - - O - - - - - - - \n- - - - - - - - - - - - - - - - - - O - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - O \n- - - - - - - - - - - - - - O - - - - - - - - - - - - - - - \n- - - - - O - - - - - - - - - - - - - - - - - - - - - - - - \n<\/code><\/pre>\n<hr \/>\n","protected":false},"excerpt":{"rendered":"<p>Par O. Bailleux, Ma\u00eetre de conf\u00e9rences HDR \u00e0 l&rsquo;universit\u00e9 de Bourgogne. Structures 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 cause [&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-238","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\/238","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=238"}],"version-history":[{"count":3,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/238\/revisions"}],"predecessor-version":[{"id":352,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/238\/revisions\/352"}],"wp:attachment":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/media?parent=238"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/categories?post=238"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/tags?post=238"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}