{"id":372,"date":"2022-03-17T21:59:28","date_gmt":"2022-03-17T21:59:28","guid":{"rendered":"https:\/\/9h15.net\/activ\/?p=372"},"modified":"2022-03-17T21:59:28","modified_gmt":"2022-03-17T21:59:28","slug":"c-et-c-partie-h","status":"publish","type":"post","link":"https:\/\/9h15.net\/activ\/c-et-c-partie-h\/","title":{"rendered":"C et C++ : partie H"},"content":{"rendered":"\n<div class=\"wp-block-jetpack-markdown\"><h1>C et C++ partie H<\/h1>\n<p><code>Par O. Bailleux, Ma\u00eetre de conf\u00e9rences HDR \u00e0 l'universit\u00e9 de Bourgogne.<\/code><\/p>\n<h1>C++ : Cha\u00eenages<\/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>Activit\u00e9 de d\u00e9couverte H.dec<\/h2>\n<p>Dans cette partie, nous explorons la mani\u00e8re d&rsquo;impl\u00e9menter des structures de donn\u00e9es, telles que des listes et des arbres, constitu\u00e9es de diff\u00e9rentes instances de classes reli\u00e9es par des pointeurs.<\/p>\n<h3>H.dec1 :  La revanche des pointeurs<\/h3>\n<h4>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Partie G<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>R\u00e9aliser des structures de donn\u00e9es extensibles qui consomment exactement la quantit\u00e9 de m\u00e9moire dont elles ont besoins.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>La classe standard <code>vector<\/code> permet de cr\u00e9er des listes extensibles, mais au prix d&rsquo;une r\u00e9servation de m\u00e9moire souvent sup\u00e9rieure aux besoins r\u00e9els. Les donn\u00e9es contenues dans une instance de <code>vector<\/code> sont physiquement stock\u00e9es dans un tableau. Nous allons \u00e9tudier une repr\u00e9sentation diff\u00e9rente.<\/p>\n<h4>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>D\u00e9composer une liste en un \u00e9l\u00e9ment de t\u00eate et une liste des autres \u00e9l\u00e9ments<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Une liste peut \u00eatre d\u00e9finie par induction de la mani\u00e8re suivante :<\/p>\n<p>Une liste est :<\/p>\n<ul>\n<li>soit vide,<\/li>\n<li>soit constitu\u00e9e d&rsquo;un \u00e9l\u00e9ment de t\u00eate et d&rsquo;une liste, appel\u00e9e reste ou queue, contenant les autres \u00e9l\u00e9ments.<\/li>\n<\/ul>\n<p>Par exemple :<\/p>\n<ul>\n<li>La liste [1, 2, 3] a pour t\u00eate 1 et pour reste la liste [2, 3].<\/li>\n<li>La liste [2, 3] a pour t\u00eate 2 et pour reste la liste [3].<\/li>\n<li>La liste [3] a pour t\u00eate 3 et pour reste la liste vide [].<\/li>\n<\/ul>\n<p>La classe suivante permet de repr\u00e9senter une liste de chaines de cette mani\u00e8re.<\/p>\n<pre><code class=\"language-c++\">class Liste\n{\nprivate:\n    Liste* reste;\n    string tete;\n    \n    Liste(const string&amp; tete, Liste* reste);\npublic:\n    Liste();\n    \n    const string&amp; getTete() const;\n    const Liste&amp; getReste() const;\n    bool estVide() const;\n    \n    void add(const string&amp; tete);\n    \n    void affiche() const;\n    void afficheDebug() const;\n    \n    int longueur() const;\n};\n<\/code><\/pre>\n<p>Examinons les attributs.<\/p>\n<ul>\n<li>Si la liste est vide, alors <code>tete<\/code> contient la liste vide <code>&quot;&quot;<\/code> et <code>reste<\/code> contient la valeur <code>null_ptr<\/code>, qui est une autre notation pour <code>NULL<\/code>.<\/li>\n<li>Si la liste n&rsquo;est pas vide, alors <code>tete<\/code> contient l&rsquo;\u00e9l\u00e9ment de t\u00eate et <code>reste<\/code> pointe le reste de la liste.<\/li>\n<\/ul>\n<p>Voici un exemple de repr\u00e9sentation en m\u00e9moire d&rsquo;une liste de deux \u00e9l\u00e9ments, <code>&quot;bbb&quot;<\/code> et <code>&quot;aaa&quot;<\/code> :<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/l2h1.png\" alt=\"l2g1\"><\/p>\n<p>La liste se pr\u00e9sente comme une succession de maillons repr\u00e9sent\u00e9s par des instances de <code>Liste<\/code>. Le dernier maillon repr\u00e9sente une liste vide et sert aussi \u00e0 terminer le cha\u00eenage.<\/p>\n<p>Il sera tout \u00e0 fait possible que le premier maillon, qui contient la t\u00eate de la liste si celle-ci n&rsquo;est pas vide (ou qui repr\u00e9sente la liste vide dans le cas contraire) soit plac\u00e9 dans la pile, mais tous les autres devront imp\u00e9rativement \u00eatre dans le tas pour \u00e9viter des probl\u00e8mes d&rsquo;accident m\u00e9moire lors de la destruction d&rsquo;une liste.<\/p>\n<hr>\n<p>Le constructeur par d\u00e9faut cr\u00e9e une liste vide. L&rsquo;attribut t\u00eate est initialis\u00e9 implicitement par le constructeur par d\u00e9faut de la classe <code>string<\/code>.<\/p>\n<pre><code class=\"language-c++\">Liste::Liste()\n{\n    reste = nullptr;\n}\n<\/code><\/pre>\n<p>Le constructeur \u00e0 deux param\u00e8tres \u00e9tend une liste par ajout d&rsquo;un \u00e9l\u00e9ment en t\u00eate. Ce constructeur est <strong>priv\u00e9<\/strong>. C&rsquo;est un choix de conception. Pour s\u00e9curiser l&rsquo;extension d&rsquo;une liste existante par ajout d&rsquo;un \u00e9l\u00e9ment en t\u00eate de liste, les personnes utilisatrices de la classe devront utiliser la m\u00e9thode publique <code>add<\/code>.<\/p>\n<pre><code class=\"language-c++\">Liste::Liste(const string&amp; tete, Liste* reste) :\ntete(tete), reste(reste)\n{\n}\n<\/code><\/pre>\n<hr>\n<p>Voici les deux m\u00e9thodes d&rsquo;acc\u00e8s :<\/p>\n<pre><code class=\"language-c++\">const string&amp; Liste::getTete() const\n{\n    return tete;\n}\n\nconst Liste&amp; Liste::getReste() const\n{\n    return *reste;\n}\n<\/code><\/pre>\n<p>Il y a plusieurs <code>const<\/code> qui apparaissent ici. Les <code>const<\/code> en d\u00e9but de ligne indiquent que les r\u00e9f\u00e9rences retourn\u00e9es ne permettent pas la modification des attributs d\u00e9sign\u00e9s par ces r\u00e9f\u00e9rences. Le retour de r\u00e9f\u00e9rences plut\u00f4t que de copies a pour seul but d&rsquo;am\u00e9liorer l&rsquo;efficacit\u00e9.<\/p>\n<p>Les <code>const<\/code> qui apparaissent en fin de ligne indique que ces m\u00e9thodes ne modifient pas les attributs de l&rsquo;instance courante (l&rsquo;instance avec laquelle elles sont appel\u00e9es).<\/p>\n<hr>\n<p>La m\u00e9thode <code>add<\/code> sera utilis\u00e9e pour l&rsquo;ajout d&rsquo;un \u00e9l\u00e9ment (une instance de <code>string<\/code>) en t\u00eate de la liste courante. <strong>Cette m\u00e9thode est con\u00e7ue de mani\u00e8re \u00e0 ne pas changer l&rsquo;adresse d&rsquo;implantation en m\u00e9moire de la t\u00eate de la liste \u00e0 modifier<\/strong>. La motivation de ce choix est d&rsquo;\u00e9viter certaines situations propices \u00e0 de futurs accidents m\u00e9moire et effets de bords, telle que cette situation&#8230;<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/l2h2.png\" alt=\"l2h2\"><\/p>\n<p>&#8230;ou m\u00eame des situations encore pires o\u00f9 plusieurs maillons seraient dans la pile.<\/p>\n<p>La d\u00e9finition de la m\u00e9thode <code>add<\/code> n&rsquo;est pas triviale et doit \u00eatre regard\u00e9e de pr\u00e8s.<\/p>\n<pre><code class=\"language-c++\">void Liste::add(const string&amp; nouvTete)\n{\n    Liste* m = new Liste(this-&gt;tete, this-&gt;reste);\n    this-&gt;tete = nouvTete;\n    this-&gt;reste = m;\n}\n<\/code><\/pre>\n<p>Pour comprendre le principe de l&rsquo;ajout d&rsquo;un nouvel \u00e9l\u00e9ment de t\u00eate <code>nouvTete<\/code>, partons de la situation suivante :<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/l2h3.png\" alt=\"l2h3\"><\/p>\n<p>La variable <code>t<\/code> d\u00e9signe la liste [&quot;aaa&quot;, &quot;bbb&quot;]. L&rsquo;instance de <code>Liste<\/code> qui contient la t\u00eate de la liste est dans la pile, mais elle pourrait \u00eatre dans le tas. Les maillons suivants sont dans le tas et ne pourraient <strong>pas<\/strong> \u00eatre dans la pile.<\/p>\n<p>On veut ajouter un nouvel \u00e9l\u00e9ment <code>&quot;ccc&quot;<\/code> en t\u00eate de liste, sans changer l&rsquo;adresse m\u00e9moire du premier maillon de la liste :<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/l2h4.png\" alt=\"l2h4\"><\/p>\n<p>L&rsquo;implantation en m\u00e9moire du premier maillon n&rsquo;a pas chang\u00e9, mais son contenu, c&rsquo;est \u00e0 dire les valeurs de ses attributs, ont chang\u00e9s. Les attributs initiaux du maillon de t\u00eate ont \u00e9t\u00e9 copi\u00e9s dans un nouveau maillon cr\u00e9\u00e9 dans le tas, qui fait office de deuxi\u00e8me maillon de la nouvelle liste.<\/p>\n<h5>Exercice de d\u00e9couverte H.dec.x1<\/h5>\n<p>Donnez les lignes de code permettant de cr\u00e9er la liste dont la repr\u00e9sentation en m\u00e9moire est illustr\u00e9e ci-dessus.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">    Liste w;\n    w.add(&quot;aaa&quot;);\n    w.add(&quot;bbb&quot;);\n    w.add(&quot;ccc&quot;);\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p>Donnez les lignes de code permettant de cr\u00e9er une liste identique, mais compl\u00e8tement dans le tas.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">    Liste* t = new Liste();\n    t-&gt;add(&quot;aaa&quot;);\n    t-&gt;add(&quot;bbb&quot;);\n    t-&gt;add(&quot;ccc&quot;);\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Examinons maintenant le code de la m\u00e9thode <code>affiche<\/code> (et celui de la m\u00e9thode <code>estVide<\/code> qu&rsquo;elle utilise).<\/p>\n<pre><code class=\"language-c++\">bool Liste::estVide() const\n{\n    return (reste == nullptr);\n}\n<\/code><\/pre>\n<pre><code class=\"language-c++\">void Liste::affiche() const\n{\n    if(estVide())\n    {\n        cout &lt;&lt; &quot;.&quot; &lt;&lt; endl;\n    }\n    else\n    {\n        cout &lt;&lt; getTete() &lt;&lt; &quot; &quot;;\n        reste-&gt;affiche();\n    }\n}\n<\/code><\/pre>\n<p>La repr\u00e9sentation d&rsquo;une liste comme \u00e9tant soit vide, soit constitu\u00e9e d&rsquo;un \u00e9l\u00e9ment de t\u00eate et d&rsquo;une liste, se pr\u00eate \u00e0 une impl\u00e9mentation r\u00e9cursive. On peut expliciter le code en fran\u00e7ais de la fa\u00e7on suivante :<\/p>\n<blockquote>\n<p>Pour afficher une liste vide, on \u00e9crit un point <code>.<\/code> \u00e0 l&rsquo;\u00e9cran.<\/p>\n<p>Pour afficher une liste non vide, on \u00e9crit \u00e0 l&rsquo;\u00e9cran son \u00e9l\u00e9ment de t\u00eate, puis on affiche la liste constitu\u00e9e du reste de ses \u00e9l\u00e9ments.<\/p>\n<\/blockquote>\n<h5>Exercice de d\u00e9couverte H.dec.x2<\/h5>\n<p>D\u00e9finissez une m\u00e9thode r\u00e9cursive <code>int Liste::longueur()<\/code> qui retourne la longueur de la liste courante.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">int Liste::longueur() const\n{\n    if(estVide()) return 0;\n    else return 1 + getReste().longueur();\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3>H.dec2 :  Lib\u00e9rer la m\u00e9moire<\/h3>\n<h4>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Parties G, H.dec1<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Lib\u00e9rer la m\u00e9moire occup\u00e9e par une liste cha\u00een\u00e9e.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>La classe pr\u00e9sent\u00e9e dans la section pr\u00e9c\u00e9dente comportait un <strong>destructeur implicite<\/strong> qui d\u00e9truit l&rsquo;instance courante, mais <strong>pas sa ramification<\/strong>.<\/p>\n<p>Si on ex\u00e9cute le code suivant&#8230;<\/p>\n<pre><code class=\"language-c++\">    Liste* w = Liste::vide();\n    w = w-&gt;add(&quot;aaa&quot;);\n    w = w-&gt;add(&quot;bbb&quot;);\n    w-&gt;affiche();\n    delete w;\n<\/code><\/pre>\n<p>&#8230;tout semble bien se passer. Mais en r\u00e9alit\u00e9 il y a une fuite m\u00e9moire.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/l2h5.png\" alt=\"l2h5\"><\/p>\n<p>Le destructeur implicite a lib\u00e9r\u00e9 uniquement la m\u00e9moire occup\u00e9e par l&rsquo;instance de Liste point\u00e9e par <code>w<\/code>, mais pas les instances suivantes dans le cha\u00eenage.<\/p>\n<p>Il nous faut impl\u00e9menter un <strong>destructeur explicite<\/strong>.<\/p>\n<h4>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Impl\u00e9menter un destructeur r\u00e9cursif<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Voici la d\u00e9finition d&rsquo;un destructeur correct de la classe <code>Liste<\/code> pr\u00e9sent\u00e9e dans la section pr\u00e9c\u00e9dente.<\/p>\n<pre><code class=\"language-c++\">Liste::~Liste()\n{\n    if(reste != nullptr)\n    {\n        delete reste;\n    }\n}\n<\/code><\/pre>\n<p>La destruction de l&rsquo;instance courante, celle \u00e0 laquelle l&rsquo;instruction <code>delete<\/code> a \u00e9t\u00e9 appliqu\u00e9e, est automatiquement r\u00e9alis\u00e9e. Le code du destructeur sert uniquement \u00e0 d\u00e9truire la ramification.<\/p>\n<p>Pour bien visualiser ce qui se passe, nous allons utiliser une version de la m\u00e9thode d&rsquo;affichage qui affiche les adresses des instances de <code>Liste<\/code> :<\/p>\n<pre><code class=\"language-c++\">void Liste::afficheDebug()\n{\n    cout &lt;&lt; &quot;@&quot; &lt;&lt; this &lt;&lt; &quot;-&gt; &quot;;\n    if(reste == nullptr)\n    {\n        cout &lt;&lt; &quot;.&quot; &lt;&lt; endl;\n    }\n    else\n    {\n        cout &lt;&lt; tete &lt;&lt; endl; \n        reste-&gt;afficheDebug();\n    }\n}\n<\/code><\/pre>\n<p>La premi\u00e8re ligne affiche <code>this<\/code>, c&rsquo;est \u00e0 dire l&rsquo;adresse de l&rsquo;instance courante.<\/p>\n<p>Nous allons \u00e9galement ajouter un affichage au destructeur :<\/p>\n<pre><code class=\"language-c++\">Liste::~Liste()\n{\n    cout &lt;&lt; &quot;Ex\u00e9cution destructeur de @&quot; &lt;&lt; this\n    if(reste != nullptr)\n    {\n        cout &lt;&lt; &quot;Appel destructeur de @&quot; &lt;&lt; reste;\n        delete reste;\n    }\n    cout &lt;&lt; &quot;Destruction de @&quot; &lt;&lt; this &lt;&lt; endl;\n}\n<\/code><\/pre>\n<p>Maintenant, ex\u00e9cutons la fonction suivante :<\/p>\n<pre><code class=\"language-c++\">void test_Liste1()\n{\n    Liste w;\n    w.add(&quot;aaa&quot;);\n    w.add(&quot;bbb&quot;);\n    w.afficheDebug();\n}\n<\/code><\/pre>\n<p>Voici l&rsquo;affichage obtenu (l&rsquo;indentation a \u00e9t\u00e9 ajout\u00e9e pour faciliter la lecture) :<\/p>\n<pre><code>@0x16fdff300-&gt; bbb\n@0x100727250-&gt; aaa\n@0x100727230-&gt; .\n\nEx\u00e9cution destructeur de @0x16fdff300 :\nAppel destructeur de @0x100727250\n    Ex\u00e9cution destructeur de @0x100727250 :\n    Appel destructeur de @0x100727230\n        Ex\u00e9cution destructeur de @0x100727230 :\n        Destruction de @0x100727230\n        Fin d'ex\u00e9cution du destructeur\n    Destruction de @0x100727250\n    Fin d'ex\u00e9cution du destructeur\nDestruction de @0x16fdff300\nFin d'ex\u00e9cution du destructeur\n<\/code><\/pre>\n<p>L&rsquo;appel du destructeur avec l&rsquo;instance <code>@0x16fdff300<\/code> (situ\u00e9e dans la pile) :<\/p>\n<ul>\n<li>appelle le destructeur avec l&rsquo;instance <code>@0x100727250<\/code> (situ\u00e9e dans le tas),<\/li>\n<li>puis d\u00e9truit effectivement l&rsquo;instance <code>@0x16fdff300<\/code>.<\/li>\n<\/ul>\n<p>L&rsquo;appel r\u00e9cursif du destructeur avec l&rsquo;instance <code>@0x100727250<\/code> :<\/p>\n<ul>\n<li>appelle le destructeur avec l&rsquo;instance <code>@0x100727230<\/code>,<\/li>\n<li>puis d\u00e9truit effectivement  l&rsquo;instance <code>@0x100727250<\/code><\/li>\n<\/ul>\n<p>L&rsquo;appel du destructeur avec l&rsquo;instance <code>@0x100727230<\/code> :<\/p>\n<ul>\n<li>n&rsquo;appelle pas de destructeur car l&rsquo;instance \u00e0 d\u00e9truire n&rsquo;a pas de ramification (c&rsquo;est le dernier maillon du  chainage).<\/li>\n<li>d\u00e9truit l&rsquo;instance <code>@0x100727230<\/code>.<\/li>\n<\/ul>\n<h5>Exercice de d\u00e9couverte H.dec.x3<\/h5>\n<p>On ex\u00e9cute la fonction suivante :<\/p>\n<pre><code class=\"language-c++\">void test_Liste2()\n{\n    Liste* w = new Liste();\n    w-&gt;add(&quot;aaa&quot;);\n    w-&gt;add(&quot;bbb&quot;);\n    w-&gt;affiche();\n}\n<\/code><\/pre>\n<p>La liste d\u00e9sign\u00e9e par <code>w<\/code> sera-t-elle compl\u00e8tement d\u00e9truite, partiellement d\u00e9truite ou pas du tout d\u00e9truite. Est-il n\u00e9cessaire d&rsquo;ajouter quelque chose pour qu&rsquo;elle soit compl\u00e8tement d\u00e9truite ?<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Elle n&rsquo;est pas d\u00e9truite du tout, car les instances de classe situ\u00e9es dans le tas (cr\u00e9\u00e9es par <code>new<\/code>) ne sont jamais d\u00e9truite automatiquement. Il faut les d\u00e9truire avec <code>delete<\/code>.<\/p>\n<p>Pour assurer la lib\u00e9ration compl\u00e8te de la m\u00e9moire, il faut \u00e9crire :<\/p>\n<pre><code class=\"language-c++\">void test_Liste2()\n{\n    Liste* w = new Liste();\n    w-&gt;add(&quot;aaa&quot;);\n    w-&gt;add(&quot;bbb&quot;);\n    w-&gt;affiche();\n    delete w;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3>H.dec3 :  Copie en profondeur<\/h3>\n<h4>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Parties G, H.dec1, H.dec2<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Cr\u00e9er une copie d&rsquo;une liste compl\u00e8tement ind\u00e9pendante en m\u00e9moire.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>La classe <code>Liste<\/code> de la section pr\u00e9c\u00e9dente n&rsquo;est pas encore suffisamment s\u00e9curis\u00e9e. Pour s&rsquo;en convaincre, examinons et ex\u00e9cutons le code suivant :<\/p>\n<pre><code class=\"language-c++\">void test_Liste3()\n{\n    Liste w;\n    w.add(&quot;aaa&quot;);\n    w.add(&quot;bbb&quot;);\n    Liste u = w;\n    w.affiche();\n    u.affiche();\n}\n<\/code><\/pre>\n<p>Apr\u00e8s l&rsquo;affichage des listes d\u00e9sign\u00e9es par <code>w<\/code> et par <code>u<\/code>, le programme plante ! Que s&rsquo;est-il pass\u00e9 ? Pour le comprendre, il faut examiner la situation en m\u00e9moire juste avant la fin de l&rsquo;ex\u00e9cution de la fonction.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/l2h6.png\" alt=\"l2h6\"><\/p>\n<p>La ligne&#8230;<\/p>\n<pre><code class=\"language-c++\">    Liste u = w;\n<\/code><\/pre>\n<p>&#8230;a invoqu\u00e9 le <strong>constructeur en copie implicite<\/strong> de la classe <code>Liste<\/code>. Cette ligne est \u00e9quivalente \u00e0 celle-ci :<\/p>\n<pre><code class=\"language-c+\">    Liste u(w);\n<\/code><\/pre>\n<p>Or ce constructeur en copie implicite r\u00e9alise une <strong>copie superficielle<\/strong>. Les valeurs des attributs de l&rsquo;instance contenue dans la variable <code>w<\/code> sont copi\u00e9s dans les attributs de l&rsquo;instance contenue dans la variable <code>u<\/code>. Il en r\u00e9sulte que les listes d\u00e9sign\u00e9es par <code>w<\/code> et <code>u<\/code> partagent la m\u00eame ramification, ce qui peut \u00eatre source d&rsquo;effets de bord, mais aussi d&rsquo;accidents m\u00e9moire.<\/p>\n<p>En l&rsquo;occurrence, \u00e0 l&rsquo;issue de l&rsquo;ex\u00e9cution de la fonction <code>test_liste3<\/code>, les variables <code>u<\/code> et <code>w<\/code> sont automatiquement d\u00e9truites par invocation du destructeur de la classe <code>Liste<\/code>. La destruction d&rsquo;une des variables entra\u00eene la destruction de l&rsquo;instance qu&rsquo;elle contient et de toute sa ramification. Ensuite, la destruction de l&rsquo;autre variable appelle une deuxi\u00e8me fois le destructeur, qui tente de d\u00e9truire \u00e0 nouveau l&rsquo;instance contenant la chaine <code>&quot;aaa&quot;<\/code>. Comme cette instance a d\u00e9j\u00e0 \u00e9t\u00e9 d\u00e9truite, il y a accident m\u00e9moire.<\/p>\n<p>Pour \u00e9viter ce probl\u00e8me, il faut d\u00e9finir un constructeur en copie explicite.<\/p>\n<h4>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Un constructeur en copie r\u00e9alisant une copie en profondeur<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Voici la d\u00e9finition d&rsquo;un constructeur en copie de la classe <code>Liste<\/code> qui r\u00e9alise une copie en profondeur de la liste utilis\u00e9e comme mod\u00e8le pour cr\u00e9er une nouvelle liste :<\/p>\n<pre><code class=\"language-c++\">Liste::Liste(const Liste&amp; modele) :\ntete(modele.tete)\n{\n    if(modele.reste==nullptr)\n    {\n        reste = nullptr;                    \/\/ Ligne A\n    }\n    else\n    {\n        reste = new Liste(*(modele.reste)); \/\/ Ligne B\n    }\n}\n<\/code><\/pre>\n<p>La cl\u00e9 de la copie en profondeur est l&rsquo;utilisation de la <strong>r\u00e9cursivit\u00e9<\/strong> : ce constructeur en copie s&rsquo;appelle lui-m\u00eame autant de fois que n\u00e9cessaire pour reproduire toute la ramification de la liste mod\u00e8le.<\/p>\n<p>Si le mod\u00e8le est une liste vide, alors <strong>la ligne A<\/strong> est ex\u00e9cut\u00e9e, ce qui a pour effet d&rsquo;assigner la valeur <code>nullptr<\/code> \u00e0 l&rsquo;attribut <code>reste<\/code> de l&rsquo;instance de <code>Liste<\/code> en cours de construction. Le r\u00e9sultat est la construction d&rsquo;une instance de <code>Liste<\/code> sans ramification qui repr\u00e9sente une liste vide.<\/p>\n<p>Si le mod\u00e8le n&rsquo;est pas une liste vide, alors <strong>la ligne B<\/strong> est ex\u00e9cut\u00e9e, ce qui a pour effet d&rsquo;appeler le constructeur en copie pour cr\u00e9er une copie en profondeur (dans le tas) de la ramification et la rattacher \u00e0 l&rsquo;instance de <code>Liste<\/code> en cours de cr\u00e9ation.<\/p>\n<p>Il faut bien comprendre l&rsquo;utilisation de l&rsquo;op\u00e9rateur de d\u00e9pointage <code>*<\/code> lors de l&rsquo;appel r\u00e9cursif du constructeur en copie. Ce constructeur a pour param\u00e8tre la r\u00e9f\u00e9rence de l&rsquo;instance de <code>Liste<\/code> \u00e0 copier. Or <code>model.reste<\/code> est un pointeur sur la liste \u00e0 copier. Pour passer la r\u00e9f\u00e9rence d&rsquo;une donn\u00e9e point\u00e9e, il faut utiliser l&rsquo;op\u00e9rateur de d\u00e9pointage.<\/p>\n<h5>Exercice de d\u00e9couverte H.dec.x4<\/h5>\n<p>Donnez les lignes de code permettant de :<\/p>\n<ul>\n<li>cr\u00e9er une liste vide dans la pile,<\/li>\n<li>puis de lui ajouter les mots <code>&quot;xxx&quot;<\/code> et <code>&quot;yyy&quot;<\/code>,<\/li>\n<li>puis de cr\u00e9er une copie de cette liste situ\u00e9e enti\u00e8rement dans le tas, en utilisant le constructeur en copie de la classe <code>Liste<\/code>,<\/li>\n<li>puis d&rsquo;afficher la liste initiale et sa copie,<\/li>\n<li>puis de lib\u00e9rer la m\u00e9moire occup\u00e9e par la copie.<\/li>\n<\/ul>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">    Liste w;\n    w.add(&quot;xxx&quot;);\n    w.add(&quot;yyy&quot;);\n    Liste* t = new Liste(w);\n    w.affiche();\n    t-&gt;affiche();\n    delete t;\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 liste vide dans le tas,<\/li>\n<li>puis de lui ajouter les mots <code>&quot;xxx&quot;<\/code> et <code>&quot;yyy&quot;<\/code>,<\/li>\n<li>puis de cr\u00e9er une copie de cette liste dans une variable de type <code>Liste<\/code> situ\u00e9e dans la pile (qui aura une ramification dans le tas), en utilisant le constructeur en copie de la classe <code>Liste<\/code>,<\/li>\n<li>puis d&rsquo;afficher la liste initiale et sa copie,<\/li>\n<li>puis de faire ce qui est n\u00e9cessaire et suffisant pour \u00e9viter toute fuite m\u00e9moire.<\/li>\n<\/ul>\n<pre><code class=\"language-c++\">    Liste* w = new Liste();\n    w-&gt;add(&quot;xxx&quot;);\n    w-&gt;add(&quot;yyy&quot;);\n    Liste t(*w);\n    w-&gt;affiche();\n    t.affiche();\n    delete w;\n<\/code><\/pre>\n<h3>H.dec4 :  Red\u00e9finition de l&rsquo;op\u00e9rateur d&rsquo;assignation<\/h3>\n<h4>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Parties G, H.dec1, H.dec2, H.dec3<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>S\u00e9curiser les copies de listes<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>La classe <code>Liste<\/code> de la section pr\u00e9c\u00e9dente n&rsquo;est pas encore suffisamment s\u00e9curis\u00e9e ! Pour s&rsquo;en convaincre, examinons et ex\u00e9cutons le code suivant :<\/p>\n<pre><code class=\"language-c++\">void test_Liste4()\n{\n    Liste w;\n    w.add(&quot;aaa&quot;);\n    w.add(&quot;bbb&quot;);\n    Liste u;\n    u.add(&quot;zzz&quot;);\n    w = u;          \/\/ Ligne A\n    w.affiche();\n    u.affiche();\n}\n<\/code><\/pre>\n<p>\u00c0 l&rsquo;ex\u00e9cution, on constate l&rsquo;affichage&#8230;<\/p>\n<pre><code>zzz .\nzzz .\n<\/code><\/pre>\n<p>&#8230;puis le programme se plante ! Pour comprendre ce qui s&rsquo;est pass\u00e9, il faut bien voir que le symbole <code>=<\/code> utilis\u00e9 <strong>en ligne A<\/strong> n&rsquo;a pas le m\u00eame sens que le symbole <code>=<\/code> de l&rsquo;exemple introductif de la section pr\u00e9c\u00e9dente. Dans la section pr\u00e9c\u00e9dente, ce symbole \u00e9tait utilis\u00e9 pour <strong>initialiser<\/strong> une variable de type <code>Liste<\/code> par appel du constructeur en copie. Ici, ce m\u00eame symbole repr\u00e9sente <strong>l&rsquo;assignation<\/strong> d&rsquo;une variable qui a d\u00e9j\u00e0 \u00e9t\u00e9 pr\u00e9alablement d\u00e9clar\u00e9e et initialis\u00e9e.<\/p>\n<p>L&rsquo;op\u00e9rateur d&rsquo;assignation utilis\u00e9 <strong>en ligne A<\/strong> r\u00e9alise une copie superficielle de l&rsquo;instance de <code>Liste<\/code> d\u00e9sign\u00e9e par la variable <code>u<\/code> dans l&rsquo;instance de <code>Liste<\/code> d\u00e9sign\u00e9e par la variable <code>w<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/l2h7.png\" alt=\"l2h7\"><\/p>\n<p>Comme le montre l&rsquo;illustration ci-dessus, la situation en m\u00e9moire \u00e0 l&rsquo;issue de l&rsquo;ex\u00e9cution de la ligne A n&rsquo;est pas reluisante. Non seulement les deux listes <code>w<\/code> et <code>u<\/code> partagent la m\u00eame ramification dans le tas, ce qui est \u00e0 l&rsquo;origine de l&rsquo;accident m\u00e9moire ayant pour effet le plantage constat\u00e9, mais en plus il y a une fuite m\u00e9moire.<\/p>\n<p>Pour \u00e9viter cela, nous allons red\u00e9finir l&rsquo;op\u00e9rateur d&rsquo;assignation.<\/p>\n<h4>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Red\u00e9finition de l&rsquo;op\u00e9rateur d&rsquo;assignation.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>S&rsquo;il n&rsquo;est pas red\u00e9fini, l&rsquo;op\u00e9rateur d&rsquo;assignation <code>=<\/code> r\u00e9alise une copie superficielle. Voici comment red\u00e9finir l&rsquo;op\u00e9rateur d&rsquo;assignation de la classe <code>Liste<\/code> pour qu&rsquo;il r\u00e9alise une copie en profondeur.<\/p>\n<pre><code class=\"language-c++\">Liste&amp; Liste::operator=(const Liste&amp; modele)\n{\/\/ D\u00e9but bloc A\n    if(reste!=nullptr)\n    {\n        delete reste;\n    }\n  \/\/ Fin bloc A\n  \n    tete = modele.tete; \/\/ Ligne B\n  \n  \/\/ D\u00e9but bloc C\n    if(modele.reste==nullptr)\n    {\n        reste = nullptr;\n    }\n    else\n    {\n        reste = new Liste(*(modele.reste));\n    }\n  \/\/ Fin bloc C\n  \n    return *this;    \/\/ Ligne D\n}\n<\/code><\/pre>\n<p>Dans le code de cette m\u00e9thode, qui est appel\u00e9e lorsque l&rsquo;op\u00e9rateur d&rsquo;assignation est utilis\u00e9, l&rsquo;instance courante de <code>Liste<\/code> est la <strong>destination<\/strong> de l&rsquo;assignation et le param\u00e8tre <code>modele<\/code> d\u00e9signe la <strong>source<\/strong>, c&rsquo;est \u00e0 dire la liste \u00e0 copier dans la destination.<\/p>\n<p><strong>Le bloc A<\/strong> lib\u00e8re, si applicable, la ramification de la liste de destination de l&rsquo;assignation. Le but est d&rsquo;\u00e9viter une fuite m\u00e9moire.<\/p>\n<p><strong>La ligne B<\/strong> remplace la t\u00eate de la liste de destination par la t\u00eate de la liste mod\u00e8le.<\/p>\n<p><strong>Le bloc C<\/strong> est identique au code du constructeur en copie. Il permet de recr\u00e9er une copie compl\u00e8te, compl\u00e8tement ind\u00e9pendante en m\u00e9moire, de la liste source.<\/p>\n<p><strong>La ligne D<\/strong> retourne la r\u00e9f\u00e9rence de l&rsquo;instance courante. Cette valeur de retour n&rsquo;est utilis\u00e9e que lors d&rsquo;assignations en chaine de la forme <code>f = g = h<\/code>, qui est autoris\u00e9e en langage C et C++. En C++, toute assignation d&rsquo;une donn\u00e9e de type primitif retourne la valeur assign\u00e9e et toute assignation d&rsquo;une instance de classe retourne la r\u00e9f\u00e9rence de l&rsquo;instance assign\u00e9e.<\/p>\n<p>Voici la situation en m\u00e9moire apr\u00e8s l&rsquo;ex\u00e9cution de la ligne A de la fonction <code>test_ligne4<\/code> apr\u00e8s red\u00e9finition de l&rsquo;op\u00e9rateur d&rsquo;assignation.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/l2h8.png\" alt=\"l2h8\"><\/p>\n<h5>Exercice de d\u00e9couverte H.dec.x5<\/h5>\n<p>Donnez les lignes de code permettant de :<\/p>\n<ul>\n<li>cr\u00e9er une liste vide dans la pile, d\u00e9sign\u00e9e par une variable <code>w<\/code>,<\/li>\n<li>puis de lui ajouter les mots <code>&quot;xxx&quot;<\/code> et <code>&quot;yyy&quot;<\/code>,<\/li>\n<li>puis de cr\u00e9er une liste vide dans le tas, point\u00e9e par une variable <code>t<\/code>,<\/li>\n<li>puis d&rsquo;assigner \u00e0 <code>w<\/code> la liste point\u00e9e par <code>t<\/code>.<\/li>\n<\/ul>\n<pre><code class=\"language-c++\">    Liste w;\n    w.add(&quot;xxx&quot;);\n    w.add(&quot;yyy&quot;);\n    Liste* t = new Liste();\n    *t = w;\n<\/code><\/pre>\n<hr>\n<p>En r\u00e9sum\u00e9, pour s\u00e9curiser la gestion m\u00e9moire lors de l&rsquo;utilisation d&rsquo;une classe avec ramification dans le tas, il y a trois choses \u00e0 faire :<\/p>\n<ol>\n<li>D\u00e9finir une <strong>destructeur<\/strong> qui lib\u00e8re toute la m\u00e9moire occup\u00e9e par la ramification de l&rsquo;instance courante.<\/li>\n<li>D\u00e9finir un <strong>constructeur en copie<\/strong> explicite qui permettant de cr\u00e9er une nouvelle instance (et sa ramification), identique \u00e0 une instance existante (et sa ramification), mais compl\u00e8tement ind\u00e9pendante en m\u00e9moire.<\/li>\n<li>Red\u00e9finir <strong>l&rsquo;op\u00e9rateur d&rsquo;assignation<\/strong> <code>=<\/code> (m\u00e9thode <code>operator=<\/code>) pour qu&rsquo;il permette de remplacer l&rsquo;instance courante (et sa ramification) par la copie d&rsquo;une autre instance (et sa ramification), sans cr\u00e9er de fuite m\u00e9moire.<\/li>\n<\/ol>\n<h2>Activit\u00e9 d&rsquo;entra\u00eenement H.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.<\/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.<\/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 refaire l&rsquo;activit\u00e9 d&rsquo;entra\u00eenement 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 certains exercices d&rsquo;entra\u00eenement apr\u00e8s un d\u00e9lai de plusieurs semaines pour \u00e9viter de perdre vos acquis.<\/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>It\u00e9ration H.ent1<\/h3>\n<h4>Exercice d&rsquo;entrainement H.ent1.1<\/h4>\n<p>Nous allons travailler avec la classe <code>Liste<\/code> d\u00e9finie dans l&rsquo;activit\u00e9 de d\u00e9couverte.<\/p>\n<pre><code class=\"language-c++\">class Liste\n{\nprivate:\n    Liste* reste;\n    string tete;\n    Liste(const string&amp; tete, Liste* reste);\npublic:\n    ~Liste();\n    Liste();\n    Liste(const Liste&amp; modele);\n    Liste&amp; operator=(const Liste&amp; modele);\n    const string&amp; getTete() const;\n    const Liste&amp; getReste() const;\n    bool estVide() const;\n    int longueur() const;\n    void add(const string&amp; tete);\n    void affiche() const;\n    void afficheDebug() const;\n};\n<\/code><\/pre>\n<h5>Question 1<\/h5>\n<p>Vous devez d\u00e9finir une m\u00e9thode r\u00e9cursive&#8230;<\/p>\n<pre><code class=\"language-c++\">void Liste::addFin(string&amp; s);\n<\/code><\/pre>\n<p>&#8230;qui ajoute la cha\u00eene d\u00e9sign\u00e9e par <code>s<\/code> \u00e0 la fin de la liste courante.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">void Liste::addFin(const string&amp; s)\n{\n    if(estVide())\n    {\n        add(s);\n    }\n    else\n    {\n        reste-&gt;addFin(s);\n    }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h5>Question 2<\/h5>\n<p>D\u00e9finissez la m\u00e9thode r\u00e9cursive&#8230;<\/p>\n<pre><code class=\"language-c++\">string Liste::getElem(int pos);\n<\/code><\/pre>\n<p>&#8230;qui retourne la chaine situ\u00e9e en position <code>pos<\/code> dans la liste courante. La t\u00eate de la liste correspond \u00e0 la position 0. Si <code>pos<\/code> est au del\u00e0 de la fin de la liste, la valeur de retour doit \u00eatre la chaine vide <code>&quot;&quot;<\/code>.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">string Liste::getElem(int pos)\n{\n    if(pos==0)\n    {\n        return getTete();\n    }\n    else if(estVide())\n    {\n        return &quot;&quot;;\n    }\n    else\n    {\n        return reste-&gt;getElem(pos-1);\n    }\n}\n<\/code><\/pre>\n<p>La seule difficult\u00e9 est de raisonner r\u00e9cursivement. L&rsquo;\u00e9l\u00e9ment en position 0 est par d\u00e9finition la t\u00eate de la liste. L&rsquo;\u00e9l\u00e9ment en position $i$ dans une liste est en position $i-1$ dans le reste de cette liste.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5>Question 3<\/h5>\n<p>D\u00e9finissez une fonction <code>essai<\/code> qui r\u00e9alise les actions suivantes :<\/p>\n<ol>\n<li>D\u00e9claration d&rsquo;une variable <code>w<\/code> de type <code>Liste<\/code> initialis\u00e9e avec le constructeur par d\u00e9faut de la classe <code>Liste<\/code>.<\/li>\n<li>Ajout de <code>&quot;aaa&quot;<\/code>, puis de <code>&quot;bbb&quot;<\/code> au d\u00e9but de la liste d\u00e9sign\u00e9e par <code>w<\/code>.<\/li>\n<li>Ajout de <code>&quot;ccc&quot;<\/code> \u00e0 la fin de de la liste d\u00e9sign\u00e9e par <code>w<\/code>.<\/li>\n<li>Affichage de la liste d\u00e9sign\u00e9e par <code>w<\/code>.<\/li>\n<li>Cr\u00e9ation dans le tas d&rsquo;une liste vide, point\u00e9e par une variable <code>u<\/code> situ\u00e9e dans la pile.<\/li>\n<li>Ajout au d\u00e9but de la liste d\u00e9sign\u00e9e par <code>u<\/code> de l&rsquo;\u00e9l\u00e9ment situ\u00e9 en position 1 dans la liste d\u00e9sign\u00e9e par <code>w<\/code>. La m\u00e9thode <code>addElem<\/code> doit \u00eatre utilis\u00e9e.<\/li>\n<li>Ajout \u00e0 la fin de la liste d\u00e9sign\u00e9e par <code>u<\/code> de l&rsquo;\u00e9l\u00e9ment situ\u00e9 en position 0 dans la liste d\u00e9sign\u00e9e par <code>w<\/code>. La m\u00e9thode <code>addElem<\/code> doit \u00eatre utilis\u00e9e.<\/li>\n<li>Affichage de la liste d\u00e9sign\u00e9e par <code>w<\/code>.<\/li>\n<li>Ce qui est n\u00e9cessaire et suffisant pour \u00e9viter toute fuite m\u00e9moire.<\/li>\n<\/ol>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">void essai()\n{\n    Liste w;\n    w.add(&quot;aaa&quot;);\n    w.add(&quot;bbb&quot;);\n    w.addFin(&quot;ccc&quot;);\n    w.affiche();\n    \n    Liste* u = new Liste();\n    u-&gt;add(w.getElem(1));\n    u-&gt;addFin(w.getElem(0));\n    u-&gt;affiche();\n    \n    delete u;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4>Exercice d&rsquo;entrainement H.ent1.2<\/h4>\n<p>Le but de cet exercice est de repr\u00e9senter des arbres binaires \u00e9tiquet\u00e9 par des entiers \u00e0 l&rsquo;aide d&rsquo;une classe <code>Arbre<\/code>.<\/p>\n<p>Voici les attributs priv\u00e9s de cette classe :<\/p>\n<pre><code class=\"language-c++\">class Arbre\n{\nprivate:\n    int val;\n    Arbre* gauche;\n    Arbre* droit;\n    \npublic :\n    \/\/ ...\n};\n<\/code><\/pre>\n<p>Un arbre est :<\/p>\n<ul>\n<li>soit vide,<\/li>\n<li>soit constitu\u00e9 d&rsquo;une \u00e9tiquette de type <code>int<\/code>, d&rsquo;un fils gauche et d&rsquo;un fils droit, qui sont des arbres.<\/li>\n<\/ul>\n<p>Un arbre vide est repr\u00e9sent\u00e9 par une instance de la classe <code>Arbre<\/code> dont l&rsquo;attribut <code>val<\/code> a pour valeur 0 et les attributs <code>gauche<\/code> et <code>droit<\/code> ont pour valeur <code>nullptr<\/code>.<\/p>\n<p>Un arbre $\\alpha$ non vide est repr\u00e9sent\u00e9 par une instance de la classe <code>Arbre<\/code> dont l&rsquo;attribut <code>val<\/code> contient l&rsquo;\u00e9tiquette racine et dont les attributs <code>gauche<\/code> et <code>droit<\/code> pointent vers des instances de la classe <code>Arbre<\/code> repr\u00e9sentant le fils gauche et le fils droit de $\\alpha$.<\/p>\n<p>Voici un exemple d&rsquo;arbre et sa repr\u00e9sentation en m\u00e9moire. Les traits inclin\u00e9s repr\u00e9sentent la valeur <code>nullptr<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/l2h9.png\" alt=\"l2h9\"><\/p>\n<p>On dote la classe <code>Arbre<\/code> d&rsquo;un constructeur par d\u00e9faut et d&rsquo;un constructeur superficiel :<\/p>\n<pre><code class=\"language-c++\">Arbre::Arbre()\n{\n    cout &lt;&lt; &quot;[D]&quot;;\n    val = 0;\n    droit = nullptr;\n    gauche = nullptr;\n}\n<\/code><\/pre>\n<pre><code class=\"language-c++\">Arbre::Arbre(int val, Arbre* g, Arbre* d)\n{\n    cout &lt;&lt; &quot;[S]&quot;;\n    this-&gt;val = val;\n    gauche = g;\n    droit = d;\n}\n<\/code><\/pre>\n<p>Le constructeur par d\u00e9faut cr\u00e9e un arbre vide. Le constructeur superficiel cr\u00e9e un arbre non vide dont les adresse des fils sont donn\u00e9es en param\u00e8tre. Il est appel\u00e9 ainsi car les fils de l&rsquo;arbre cr\u00e9\u00e9 ne sont <strong>pas<\/strong> des copies des arbres d\u00e9sign\u00e9s par les param\u00e8tre, avec les risques que cela comporte en termes d&rsquo;accident m\u00e9moire et de fuite m\u00e9moire. (Plusieurs arbres peuvent avoir des sous-arbres communs.)<\/p>\n<p>Les affichages ajout\u00e9s vont permettre de comptabiliser le nombre d&rsquo;instances cr\u00e9\u00e9es par chacun des constructeurs dans un but p\u00e9dagogique et de mise au point.<\/p>\n<h5>Question 1.<\/h5>\n<p>Donnez les lignes de code permettant de construire l&rsquo;arbre donn\u00e9 en exemple ci-dessus, situ\u00e9 compl\u00e8tement dans le tas.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">    Arbre* a = new Arbre(9, new Arbre(), new Arbre());\n    Arbre* r = new Arbre(5, new Arbre(), a);\n<\/code><\/pre>\n<p>L&rsquo;arbre complet construit est point\u00e9 par la variable <code>r<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>On ajoute une m\u00e9thode permettant de d\u00e9terminer si l&rsquo;arbre courant est vide :<\/p>\n<pre><code class=\"language-c++\">bool Arbre::vide() const\n{\n    return gauche == nullptr;\n}\n<\/code><\/pre>\n<p>Le test est r\u00e9alis\u00e9 avec l&rsquo;attribut <code>gauche<\/code>, sachant que si l&rsquo;arbre est vide, alors les deux attributs <code>gauche<\/code> et <code>droit<\/code> contiennent la valeur <code>nullptr<\/code>, et que dans le cas contraire, aucun des deux attributs ne contient cette valeur.<\/p>\n<h5>Question 2<\/h5>\n<p>D\u00e9finissez le destructeur de la classe <code>Arbre<\/code>.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">Arbre::~Arbre()\n{\n    if(!vide())\n    {\n        delete gauche;\n        delete droit;\n    }\n    cout &lt;&lt; &quot;[X]&quot;;\n}\n<\/code><\/pre>\n<p>Un affichage a \u00e9t\u00e9 ajout\u00e9 pour permettre de visualiser les destructions \u00e0 des fins p\u00e9dagogiques et de mise au point.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h6>Question 3<\/h6>\n<p>D\u00e9finissez la m\u00e9thode&#8230;<\/p>\n<pre><code class=\"language-c++\">void Arbre::affiche();\n<\/code><\/pre>\n<p>&#8230;qui affiche l&rsquo;arbre courant dans le format illustr\u00e9 par l&rsquo;exemple suivant :<\/p>\n<pre><code>5(.,9(.,.))\n<\/code><\/pre>\n<p>Les points <code>.<\/code> repr\u00e9sentent des arbres vides.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">void Arbre::affiche() const\n{\n    if(vide())\n    {\n        cout &lt;&lt; &quot;.&quot;;\n    }\n    else\n    {\n        cout &lt;&lt; val &lt;&lt; &quot;(&quot;;\n        gauche-&gt;affiche();\n        cout &lt;&lt; &quot;,&quot;;\n        droit-&gt;affiche();\n        cout &lt;&lt; &quot;)&quot;;\n    }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h5>Question 4<\/h5>\n<p>Reprenez la solution de la question 1, qui cr\u00e9e un arbre dans le tas, et compl\u00e9tez l\u00e0 en ajoutant les lignes de code permettant d&rsquo;afficher l&rsquo;arbre cr\u00e9\u00e9, puis de lib\u00e9rer la m\u00e9moire qu&rsquo;il occupe.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">    Arbre* a = new Arbre(9, new Arbre(), new Arbre());\n    Arbre* r = new Arbre(5, new Arbre(), a);\n    cout &lt;&lt; endl;\n    r-&gt;affiche();\n    cout &lt;&lt; endl;\n    delete r;\n<\/code><\/pre>\n<p>Il ne faut surtout pas ajouter la ligne <code>delete a<\/code>, car l&rsquo;arbre point\u00e9 par <code>a<\/code> est le fils droit de l&rsquo;arbre point\u00e9 par <code>r<\/code> et sera d\u00e9truit par <code>delete r<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5>Question 5<\/h5>\n<p>Le constructeur par d\u00e9faut affiche <code>[D]<\/code> lors de son ex\u00e9cution. Le constructeur superficiel affiche <code>[S]<\/code>, et le destructeur affiche <code>[X]<\/code>.<\/p>\n<p>Donnez l&rsquo;affichage exact produit par l&rsquo;ex\u00e9cution de la solution de la question 4.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code>[D][D][S][D][S]\n5(.,9(.,.))\n[X][X][X][X][X]\n<\/code><\/pre>\n<p>Les deux premiers <code>[D]<\/code> correspondent aux deux <code>new Arbre()<\/code> de la premi\u00e8re ligne. Le <code>[S]<\/code> suivant correspond \u00e0 l&rsquo;appel du constructeur superficiel de la premi\u00e8re ligne. Le <code>[D]<\/code> et le <code>[S]<\/code> suivants sont affich\u00e9s par l&rsquo;appel du constructeur par d\u00e9faut et du constructeur superficiel de la deuxi\u00e8me ligne.<\/p>\n<p>Tout ces appels ont cr\u00e9\u00e9 au total 5 instance de <code>Arbre<\/code> dans le tas. Chacune d&rsquo;elles est d\u00e9truite lors de l&rsquo;ex\u00e9cution du destructeur de l&rsquo;arbre point\u00e9 par <code>r<\/code>. Il y a donc 5 affichages de <code>[X]<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3>Exercice d&rsquo;entrainement H.ent1.3<\/h3>\n<p>On reprend la classe <code>Arbre<\/code> de l&rsquo;exercice pr\u00e9c\u00e9dent avec ses constructeurs, destructeurs et m\u00e9thodes apparaissant dans la d\u00e9claration suivante, et qui sont suppos\u00e9s \u00eatre correctement impl\u00e9ment\u00e9s.<\/p>\n<pre><code class=\"language-c++\">class Arbre\n{\nprivate:\n    int val;\n    Arbre* gauche;\n    Arbre* droit;\n    \npublic:\n    Arbre();\n    Arbre(int val, Arbre* g, Arbre* d);\n    Arbre(int val, const Arbre&amp; g, const Arbre&amp; d);\n    ~Arbre();\n    \n    bool vide() const;\n    void affiche() const;\n};\n<\/code><\/pre>\n<p>Un nouveau constructeur, appel\u00e9 <strong>constructeur en profondeur<\/strong>, apparait. Voici sa d\u00e9finition :<\/p>\n<pre><code class=\"language-c++\">Arbre::Arbre(int val, const Arbre&amp; g, const Arbre&amp; d)\n{\n    cout &lt;&lt; &quot;[P]&quot;;\n    this-&gt;val = val;\n    gauche = new Arbre(g);\n    droit = new Arbre(d);\n}\n<\/code><\/pre>\n<p>Ce constructeur fait appel aux constructeur en copie pour cr\u00e9er les fils gauche et droit de l&rsquo;arbre en cours de construction \u00e0 partir de copies des arbres dont les r\u00e9f\u00e9rences sont pass\u00e9es en param\u00e8tres.<\/p>\n<p>Lors de son ex\u00e9cution, ce constructeur affiche <code>[P]<\/code> dans un but p\u00e9dagogique et de mise au point. Pour m\u00e9moire, le constructeur superficiel affiche <code>[S]<\/code>, le constructeur par d\u00e9faut affiche <code>[D]<\/code> et le destrcuteur affiche <code>[X]<\/code>.<\/p>\n<h5>Question 1<\/h5>\n<p>D\u00e9finissez le constructeur en copie de la classe <code>Arbre<\/code>. Ce constructeur doit permettre de cr\u00e9er un nouvel arbre identique \u00e0 un arbre existant. La copie et l&rsquo;original doivent \u00eatre compl\u00e8tement ind\u00e9pendants en m\u00e9moire. L&rsquo;ex\u00e9cution de ce constructeur doit afficher <code>[C]<\/code>.<\/p>\n<pre><code class=\"language-c++\">Arbre::Arbre(const Arbre&amp; m)\n{\n    \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;Indice&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">Arbre::Arbre(const Arbre&amp; m)\n{\n    cout &lt;&lt; &quot;[C]&quot;;\n    val = m.val;\n    if(vide())\n    {\n        gauche = nullptr; droit = nullptr;\n    }\n    else\n    {\n        \/\/ \u00c0 compl\u00e9ter\n    }\n}\n<\/code><\/pre>\n<p>Dans tous les cas, l&rsquo;attribut <code>val<\/code> du mod\u00e8le est recopi\u00e9 dans l&rsquo;attribut <code>val<\/code> de l&rsquo;instance cr\u00e9\u00e9e. Si le mod\u00e8le est un arbre vide, alors l&rsquo;instance cr\u00e9\u00e9e repr\u00e9sente aussi un arbre vide.<\/p>\n<p>Il reste \u00e0 traiter la cas o\u00f9 le mod\u00e8le n&rsquo;est pas vide, donc a un fils gauche et un fils droit. Les attributs <code>gauche<\/code> et <code>droit<\/code> de l&rsquo;instance cr\u00e9\u00e9e doivent pointer sur des <strong>copies<\/strong> des fils du mod\u00e8le.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">Arbre::Arbre(const Arbre&amp; m)\n{\n    cout &lt;&lt; &quot;[C]&quot;;\n    val = m.val;\n    if(m.vide())\n    {\n        gauche = nullptr; droit = nullptr;\n    }\n    else\n    {\n        gauche = new Arbre(*(m.gauche));\n        droit = new Arbre(*(m.droit));\n    }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h5>Question 2<\/h5>\n<p>On ex\u00e9cute la fonction suivante&#8230;<\/p>\n<pre><code class=\"language-c++\">void test_Arbre1()\n{\n    Arbre a(12, Arbre(), Arbre());\n    cout &lt;&lt; endl;\n    a.affiche();\n    cout &lt;&lt; endl;\n}\n<\/code><\/pre>\n<p>&#8230;et on obtient l&rsquo;affichage :<\/p>\n<pre><code>[D][D][P][C][C][X][X]\n12(.,.)\n[X][X][X]\n<\/code><\/pre>\n<p>Ce qui signifie que :<\/p>\n<ul>\n<li>le constructeur par d\u00e9faut est invoqu\u00e9 2 fois,<\/li>\n<li>le constructeur en profondeur est invoqu\u00e9 1 fois,<\/li>\n<li>le constructeur en copie est invoqu\u00e9 2 fois,<\/li>\n<li>et que le destructeur est invoqu\u00e9 5 fois.<\/li>\n<\/ul>\n<p>D\u00e9taillez toutes les \u00e9tapes et tentez de comprendre et d&rsquo;expliquer pourquoi il y a eu 5 appels de constructeur pour cr\u00e9er un arbre constitu\u00e9 de seulement 3 instances de la classe <code>Arbre<\/code>.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;Indice&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Tous les appels de constructeur sont r\u00e9alis\u00e9s par la premi\u00e8re ligne. On peut identifier trois \u00e9tapes de l&rsquo;ex\u00e9cution de la premi\u00e8re ligne.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/l2h10.png\" alt=\"l2h10\"><\/p>\n<ul>\n<li>\u00c0 l&rsquo;\u00e9tape 1, un arbre vide anonyme est cr\u00e9\u00e9 dans la pile. Cet arbre n&rsquo;est pas stock\u00e9 dans une variable et sera d\u00e9truit automatiquement.<\/li>\n<li>\u00c0 l&rsquo;\u00e9tape 2, un autre arbre anonyme est cr\u00e9\u00e9 dans la pile.<\/li>\n<\/ul>\n<p>Ceci nous donne l&rsquo;explication des deux premiers [D], c&rsquo;est \u00e0 dire des deux invocations du constructeur par d\u00e9faut.<\/p>\n<p>Mais pourquoi y a t&rsquo;il \u00e0 l&rsquo;\u00e9tape 3 une invocation du constructeur en profondeur et deux invocations du constructeur en copie ? \u00c0 vous de continuer l&rsquo;enqu\u00eate. Regardez le code du constructeur en profondeur.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Comme les \u00e9tapes 1 et 2 ne produisent pas des pointeurs mais de instances de la classe <code>Arbre<\/code>, c&rsquo;est le constructeur en profondeur qui est invoqu\u00e9 \u00e0 l&rsquo;\u00e9tape 3 pour initialiser la variable <code>a<\/code>.<\/p>\n<p>En examinant le code de ce constructeur, on constate qu&rsquo;il cr\u00e9e deux instances de <code>Liste<\/code> en appelant avec <code>new<\/code> le <strong>constructeur en copie<\/strong> de la classe <code>Liste<\/code>. C&rsquo;est la raison pour laquelle on a deux fois l&rsquo;affichage <code>[C]<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p>\u00c0 quoi correspondent les deux premiers <code>[X]<\/code> affich\u00e9s ? Et les trois derniers ?<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Les deux premiers <code>[X]<\/code> correspondent \u00e0 le destruction automatique des deux instances anonymes de la classe <code>Arbre<\/code> cr\u00e9\u00e9es aux \u00e9tapes 1 et 2.<\/p>\n<p>Les trois derniers <code>[X]<\/code> correspondent \u00e0 la destruction automatique de l&rsquo;arbre d\u00e9sign\u00e9 par la variable <code>a<\/code>, incluant les deux arbres vides de sa ramification.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5>Question 3<\/h5>\n<p>Donnez la d\u00e9finition de la m\u00e9thode&#8230;<\/p>\n<pre><code class=\"language-c++\">Arbre&amp; Arbre::operator=(const Arbre&amp; m);\n<\/code><\/pre>\n<p>&#8230;qui impl\u00e9mente l&rsquo;op\u00e9rateur <code>=<\/code> de mani\u00e8re \u00e0 ce que si les variables a et b d\u00e9signent deux arbres existants, appel\u00e9s respectivement l&rsquo;arbre cible et l&rsquo;arbre source, l&rsquo;assignation <code>a = b<\/code> ait les effets suivants :<\/p>\n<ol>\n<li>Destruction de toute la ramification de l&rsquo;arbre d\u00e9sign\u00e9 par <code>a<\/code>.<\/li>\n<li>Remplacement de cet arbre par une copie en profondeur de l&rsquo;arbre d\u00e9sign\u00e9 par <code>b<\/code>.<\/li>\n<\/ol>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;Indice1&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">Arbre&amp; Arbre::operator=(const Arbre&amp; m)\n{\n    val = m.val;                     \/\/ Ligne A\n    if(!vide())\n    {\n        delete gauche; delete droit; \/\/ ligne B\n    }\n    \/\/ \u00c0 compl\u00e9ter\n    return *this;\n}\n<\/code><\/pre>\n<p>La <strong>ligne A<\/strong> copie la chaine associ\u00e9e \u00e0 la racine de l&rsquo;arbre source dans l&rsquo;instance courante qui repr\u00e9sente la racine de l&rsquo;arbre cible.<\/p>\n<p>La <strong>ligne B<\/strong> d\u00e9truit la ramification de l&rsquo;arbre cible, si applicable, c&rsquo;est \u00e0 dire si l&rsquo;arbre cible n&rsquo;est pas une feuille.<\/p>\n<p>La partie \u00e0 compl\u00e9ter doit r\u00e9aliser la copie en profondeur des fils gauche et droit de l&rsquo;arbre source dans l&rsquo;arbre cible. Il faut utiliser le constructeur en copie de la classe <code>Arbre<\/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\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">Arbre&amp; Arbre::operator=(const Arbre&amp; m)\n{\n    val = m.val;\n    if(!vide())\n    {\n        delete gauche; delete droit;\n    }\n    if(m.vide())\n    {\n        gauche = nullptr; droit = nullptr;\n    }\n    else\n    {\n        gauche = new Arbre(*(m.gauche));\n        droit = new Arbre(*(m.droit));\n    }\n    return *this;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h5>Question 4<\/h5>\n<p>On consid\u00e8re le fonction suivante :<\/p>\n<pre><code class=\"language-c++\">void testArbre(void)\n{\n    Arbre f;            \/\/ Ligne A\n    Arbre a(12, f, f);  \/\/ Ligne B\n    Arbre b(9, f, f);   \/\/ Ligne C\n    Arbre c(3, a, b);   \/\/ Ligne D\n    c.affiche(); cout &lt;&lt; endl;\n    a = c;              \/\/ Ligne E\n    a.affiche(); cout &lt;&lt; endl;\n}\n<\/code><\/pre>\n<p>Combien de fois le constructeur par d\u00e9faut est-il appel\u00e9, et (si applicable) lors de l&rsquo;ex\u00e9cution de quelles lignes ?<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Une seule fois, lors de l&rsquo;ex\u00e9cution de la ligne A.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Combien de fois le constructeur en copie est il appel\u00e9 au cours de l&rsquo;ex\u00e9cution de la ligne B ?<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Deux fois, par le constructeur en profondeur qui cr\u00e9e deux copies de l&rsquo;arbre d\u00e9sign\u00e9 par <code>f<\/code> (les fils gauche et droit de l&rsquo;arbre d\u00e9sign\u00e9 par <code>a<\/code>).<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>On adopte la repr\u00e9sentation simplifi\u00e9e suivante pour repr\u00e9senter l&rsquo;arbre d\u00e9sign\u00e9 par <code>a<\/code> \u00e0 l&rsquo;issue de l&rsquo;ex\u00e9cution de la ligne B. Le triangle noir en haut \u00e0 gauche d&rsquo;une instance signifie qu&rsquo;elle est situ\u00e9e dans la pile.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/l2h11.png\" alt=\"l2h11\"><\/p>\n<p>Dessinez la situation compl\u00e8te en m\u00e9moire \u00e0 l&rsquo;issue de l&rsquo;ex\u00e9cution des lignes A, B, C et D.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/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\/03\/l2h12.png\" alt=\"l2h12\"><\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Combien de fois le constructeur en copie est il appel\u00e9 au cours de l&rsquo;ex\u00e9cution de la ligne D ?<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Six fois. Trois fois pour cr\u00e9er le fils gauche de l&rsquo;arbre construit dans <code>c<\/code>, et trois fois pour cr\u00e9er son fils droit. On le voit facilement sur le dessin en comptant les instances de la ramification de l&rsquo;arbre d\u00e9sign\u00e9 par <code>c<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Quels sont les constructeurs appel\u00e9s lors de l&rsquo;ex\u00e9cution de la ligne E, et combien de fois ? Le destructeur est-il appel\u00e9 lors de l&rsquo;ex\u00e9cution de cette ligne, et si oui combien de fois ?<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Les destructeur est appel\u00e9 deux fois pour d\u00e9truire la ramification de l&rsquo;arbre d\u00e9sign\u00e9 par <code>a<\/code>. Les constructeur en copie est appel\u00e9 6 fois pour remplacer les fils gauche et droit de l&rsquo;arbre d\u00e9sign\u00e9 par <code>a<\/code> par des copies des fils gauche et droit de l&rsquo;arbre d\u00e9sign\u00e9 par <code>c<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<\/div>\n","protected":false},"excerpt":{"rendered":"","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-372","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\/372","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=372"}],"version-history":[{"count":1,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/372\/revisions"}],"predecessor-version":[{"id":393,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/372\/revisions\/393"}],"wp:attachment":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/media?parent=372"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/categories?post=372"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/tags?post=372"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}