{"id":332,"date":"2022-03-02T20:50:32","date_gmt":"2022-03-02T20:50:32","guid":{"rendered":"https:\/\/9h15.net\/activ\/?p=332"},"modified":"2022-03-02T20:50:32","modified_gmt":"2022-03-02T20:50:32","slug":"c-et-c-partie-g","status":"publish","type":"post","link":"https:\/\/9h15.net\/activ\/c-et-c-partie-g\/","title":{"rendered":"C et C++ : Partie G"},"content":{"rendered":"\n<div class=\"wp-block-jetpack-markdown\"><h1>C et C++ partie G<\/h1>\n<p><code>Par O. Bailleux, Ma\u00eetre de conf\u00e9rences HDR \u00e0 l'universit\u00e9 de Bourgogne.<\/code><\/p>\n<h1>C++ : classes et instances<\/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 G.dec<\/h2>\n<p>Dans cet enseignement, nous n&rsquo;aborderons qu&rsquo;un <strong>fragment<\/strong> du langage C++. De nombreux aspects ne seront pas abord\u00e9s.<\/p>\n<h3>G.dec1 :  Utilisation d&rsquo;une classe<\/h3>\n<p>Dans cette section, nous allons d\u00e9couvrir la notion de <strong>classe<\/strong> en <strong>programmation orient\u00e9e objet<\/strong> du point de vue de l&rsquo;<strong>utilisation<\/strong> d&rsquo;une classe existante, en l&rsquo;occurrence la classe <code>string<\/code>, qui permet de repr\u00e9senter des chaines de caract\u00e8res.<\/p>\n<h4>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Parties A, C et D<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Faciliter l&rsquo;utilisation de cha\u00eenes de caract\u00e8res<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>La repr\u00e9sentation des cha\u00eenes en langage C (partie D) est tr\u00e8s rudimentaire, avec pour cons\u00e9quence des risques important d&rsquo;erreurs, de &quot;bugs&quot; lors de la conception d&rsquo;applications les utilisant.<\/p>\n<p>L&rsquo;objectif de la classe <code>string<\/code> du C++, qui nous sert ici d&rsquo;exemple introductif pour pr\u00e9senter le concept de classe du point de vue de leur utilisation, est de rendre plus simple et plus s\u00e9curis\u00e9e l&rsquo;utilisation de chaines de caract\u00e8res dans des applications.<\/p>\n<h4>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>La classe string du C++<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Dans cette section, nous nous int\u00e9ressons \u00e0 la classe <code>string<\/code> vue de l&rsquo;ext\u00e9rieur, c&rsquo;est \u00e0 dire sans nous soucier de la mani\u00e8re dont elle est programm\u00e9e. C&rsquo;est un des int\u00e9r\u00eats de la programmation objet de rendre l&rsquo;utilisation d&rsquo;une classe compl\u00e8tement ind\u00e9pendante de sa conception.<\/p>\n<p>Une <strong>classe<\/strong> est en quelques sorte un mod\u00e8le permettant de cr\u00e9er des <strong>objets<\/strong> qui sont aussi appel\u00e9s <strong>instances<\/strong> de la classe.<\/p>\n<p>Les instances de la classe <code>string<\/code> repr\u00e9sentent des cha\u00eenes de caract\u00e8res. Elles peuvent se trouver dans la pile ou dans le tas. L&rsquo;exemple suivant montre comment cr\u00e9er une instance de <code>string<\/code> dans la pile et une autre dans le tas.<\/p>\n<p>Pour compiler cet exemple, il faut placer les lignes suivantes au d\u00e9but du fichier source :<\/p>\n<pre><code class=\"language-C\">#include &lt;iostream&gt;\n#include &lt;string&gt;\nusing namespace std;\n<\/code><\/pre>\n<p>Les deux premi\u00e8res lignes sont des inclusions de fichiers d&rsquo;ent\u00eate. La troisi\u00e8me permettra d&rsquo;utiliser par d\u00e9faut l&rsquo;espace de nommage <code>std<\/code>. Sans cette ligne, la classe <code>string<\/code> devrait \u00eatre nomm\u00e9e <code>std::string<\/code>.  Les espaces de nommage permettent d&rsquo;utiliser un m\u00eame nom pour d\u00e9signer plusieurs classes dans des contextes diff\u00e9rents. Par exemple, nous pourrions d\u00e9finir notre propre classe <code>string<\/code>, diff\u00e9rente de celle du C++ en utilisant un autre espace de nommage.<\/p>\n<p>Voici les lignes de code qui nous int\u00e9ressent :<\/p>\n<pre><code class=\"language-C++\">int main()\n{\n    string s1(&quot;ABC&quot;);                  \/\/ Ligne A\n    string* s2 = new string(&quot;XYZ&quot;);    \/\/ Ligne B\n    cout &lt;&lt; s1 &lt;&lt; &quot; &quot; &lt;&lt;  *s2 &lt;&lt; endl; \/\/ Ligne C\n    delete s2;                         \/\/ Ligne D\n    return 0;\n}\n<\/code><\/pre>\n<p>On reconnait la fonction <code>main<\/code> qui a le m\u00eame r\u00f4le qu&rsquo;en langage C. La plupart des \u00e9l\u00e9ments du langage C appartiennent aussi au C++.<\/p>\n<p><strong>La ligne A<\/strong> cr\u00e9e une variable <code>s1<\/code> dans la pile et place dans cette variable une instance de <code>string<\/code> repr\u00e9sentant la cha\u00eene <code>&quot;ABC&quot;<\/code>.  Cette d\u00e9claration de la variable <code>s1<\/code> appelle un <strong>constructeur<\/strong> de la classe <code>string<\/code> en lui passant en param\u00e8tre la cha\u00eene constante <code>&quot;ABC&quot;<\/code> qui est dans le format de repr\u00e9sentation des cha\u00eenes du langage C, vue en partie D.<\/p>\n<p><strong>La ligne B<\/strong> cr\u00e9e dans la pile une variable <code>s2<\/code> de type pointeur sur <code>string<\/code>, cr\u00e9e dans le tas une instance de <code>string<\/code> initialis\u00e9e avec la cha\u00eene <code>&quot;XYZ&quot;<\/code>, et place l&rsquo;adresse de cette instance dans la variable <code>s2<\/code>. Le <strong>constructeur<\/strong> de la classe <code>string<\/code> est appel\u00e9 par l&rsquo;instruction <code>new<\/code>. Cette instruction <code>new<\/code> est utilis\u00e9e pour cr\u00e9er des instances de classe dans le tas mais pas pour cr\u00e9er des instances dans la pile.<\/p>\n<p><strong>La ligne C<\/strong> permet l&rsquo;affichage des cha\u00eenes d\u00e9sign\u00e9es par les variables <code>s1<\/code> et <code>s2<\/code>. La fonction <code>printf<\/code> du C est utilisable en C++ mais ne permet pas d&rsquo;afficher des instances de la classe <code>string<\/code>. La mani\u00e8re standard d&rsquo;afficher des donn\u00e9es en C++ consiste \u00e0 les envoyer dans le <strong>flux de sortie standard<\/strong> <code>cout<\/code>. La valeur <code>endl<\/code> repr\u00e9sente un passage \u00e0 la ligne. Comme se sont les instances de <code>string<\/code> qui doivent \u00eatre affich\u00e9es et non leur adresses, l&rsquo;affichage de l&rsquo;instance de <code>string<\/code> point\u00e9e par <code>s2<\/code> n\u00e9cessite un &quot;d\u00e9pointage&quot; not\u00e9 <code>*s2<\/code>. En C++, les pointeurs sont identiques \u00e0 ceux du C et les notations pour leurs d\u00e9claration et utilisation sont aussi les m\u00eames.<\/p>\n<p><strong>La ligne D<\/strong> lib\u00e8re la m\u00e9moire occup\u00e9e par l&rsquo;instance de <code>string<\/code> situ\u00e9e dans le tas, qui est point\u00e9e par <code>s2<\/code>. Comme en langage C, toute cr\u00e9ation de bloc m\u00e9moire dans le tas entra\u00eene une &quot;dette m\u00e9moire&quot; qu&rsquo;il faut rembourser avant la fin de l&rsquo;ex\u00e9cution du programme.<\/p>\n<p>La m\u00e9moire occup\u00e9e dans la pile par l&rsquo;instance de <code>string<\/code> contenue dans <code>s1<\/code> est lib\u00e9r\u00e9e automatiquement, comme c&rsquo;est le cas pour toute variable locale.<\/p>\n<p>Examinons ce qui se passe dans la m\u00e9moire \u00e0 l&rsquo;issue de l&rsquo;ex\u00e9cution de la ligne B.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/l2g1.png\" alt=\"l2g1\"><\/p>\n<p>La figure ci-dessus utilise une <strong>repr\u00e9sentation simplifi\u00e9e<\/strong> d&rsquo;une instance de <code>string<\/code> vue comme une sorte de bloc contenant une cha\u00eene. La repr\u00e9sentation r\u00e9elle en m\u00e9moire est plus complexe et comporte une ramification dans le tas, y compris si l&rsquo;instance est dans la pile. Mais on peut utiliser la classe en faisant abstraction de la repr\u00e9sentation r\u00e9elle des donn\u00e9es associ\u00e9e \u00e0 chacune de ses instances.<\/p>\n<p>La repr\u00e9sentation r\u00e9elle, ou concr\u00e8te, des instances d&rsquo;une classe nous int\u00e9ressera lorsque nous seront amen\u00e9 \u00e0 impl\u00e9menter cette classe. Mais si elle est correctement impl\u00e9ment\u00e9e, en respectant les bonnes pratiques de gestion de la m\u00e9moire qui seront introduites dans la partie H, nous pourrons raisonner uniquement avec la repr\u00e9sentation simplifi\u00e9e lors de l&rsquo;utilisation d&rsquo;une classe.<\/p>\n<hr>\n<p>Une classe comporte g\u00e9n\u00e9ralement des <strong>m\u00e9thodes d&rsquo;instance<\/strong> permettant d&rsquo;agir sur ses instances. Une telle m\u00e9thode s&rsquo;appelle avec une instance de la classe dans laquelle elle est d\u00e9finie. Voici un exemple avec la m\u00e9thode d&rsquo;instance <code>size<\/code> de la classe <code>string<\/code>, qui retourne la longueur de la cha\u00eene repr\u00e9sent\u00e9e :<\/p>\n<pre><code class=\"language-C++\">    string s1(&quot;ABC&quot;);\n    string* s2 = new string(&quot;XYZ&quot;);\n    cout &lt;&lt; s1.size() &lt;&lt; endl;      \/\/ Ligne A\n    cout &lt;&lt; s2-&gt;size() &lt;&lt; endl;     \/\/ Ligne B\n<\/code><\/pre>\n<p><strong>En ligne A<\/strong>, la m\u00e9thode <code>size<\/code> est appel\u00e9e avec l&rsquo;instance de <code>string<\/code> contenue dans la variable <code>s1<\/code>. Notez l&rsquo;utilisation du point : <code>s1.size()<\/code>.<\/p>\n<p><strong>En ligne B<\/strong>, la m\u00e9thode <code>size<\/code> est appel\u00e9e avec l&rsquo;instance de <code>string<\/code> point\u00e9e par la variable <code>s2<\/code>. On utilise alors la fl\u00e8che : <code>s2-&gt;size()<\/code>.<\/p>\n<p>Ces notations sont similaires \u00e0 celles utilis\u00e9es en C avec les instances de structures, sauf qu&rsquo;ici elles permettent l&rsquo;acc\u00e8s \u00e0 des <strong>m\u00e9thodes<\/strong> et non \u00e0 des champs (qui repr\u00e9sentent des donn\u00e9es).<\/p>\n<hr>\n<p>Le langage C++ permet la <strong>surcharge des op\u00e9rateurs<\/strong>. Un op\u00e9rateur surcharg\u00e9 a un comportement sp\u00e9cifique lorsqu&rsquo;il est appliqu\u00e9 \u00e0 des instances de la classe pour laquelle il est surcharg\u00e9. Nous ne verrons pas comment impl\u00e9menter des op\u00e9rateurs surcharg\u00e9s (except\u00e9 l&rsquo;op\u00e9rateur <code>=<\/code>) mais nous utiliserons des op\u00e9rateurs surcharg\u00e9s de la classe <code>string<\/code>. Voici quelques exemples :<\/p>\n<pre><code class=\"language-C\">    string t = &quot;abc&quot;;   \/\/ Ligne A\n    string u = &quot;def&quot;;   \/\/ Ligne B\n    t = t + u;          \/\/ ligne C\n    u = t + &quot;ghi&quot;;      \/\/ Ligne D\n    cout &lt;&lt; u &lt;&lt; endl;\n<\/code><\/pre>\n<p>L&rsquo;op\u00e9rateur <code>=<\/code> de la <strong>ligne A<\/strong> (tout comme celui de la ligne  B) est surcharg\u00e9 de mani\u00e8re \u00e0 permettre l&rsquo;initialisation d&rsquo;une instance de <code>string<\/code> avec une cha\u00eene au format C. A gauche, la variable <code>t<\/code> est de type <code>string<\/code> alors qu&rsquo;\u00e0 droite, la constante litt\u00e9rale <code>&quot;abc&quot;<\/code> est de type <code>char*<\/code>. Derri\u00e8re cette syntaxe simple se cache en fait un m\u00e9canisme sophistiqu\u00e9 qui invoque un <strong>constructeur<\/strong> de la classe <code>string<\/code>. Nous y reviendrons plus tard.<\/p>\n<p>L&rsquo;op\u00e9rateur <code>+<\/code> de la <strong>ligne C<\/strong> est \u00e9galement surcharg\u00e9 pour permettre la concat\u00e9nation de deux cha\u00eenes. Il s&rsquo;applique \u00e0 deux instances de <code>string<\/code> et a pour r\u00e9sultat une instance de <code>string<\/code>. L&rsquo;op\u00e9rateur <code>=<\/code> de cette m\u00eame ligne n&rsquo;a pas le m\u00eame r\u00f4le que celui des lignes A et B. \u00c0 gauche et \u00e0 droite de cet op\u00e9rateur, il y a des instances de <code>string<\/code>.<\/p>\n<p>L&rsquo;op\u00e9rateur <code>+<\/code> de la <strong>ligne D<\/strong> est \u00e9galement surcharg\u00e9, mais ce n&rsquo;est pas  le m\u00eame que celui de la ligne C. Celui-ci permet de concat\u00e9ner \u00e0 une chaine repr\u00e9sent\u00e9e par une instance de <code>string<\/code> (\u00e0 gauche) une chaine au format C (\u00e0 droite).<\/p>\n<p>L&rsquo;affichage produit par l&rsquo;ex\u00e9cution est :<\/p>\n<pre><code>abcdefghi\n<\/code><\/pre>\n<h5>Exercice de d\u00e9couverte G.dec.x1<\/h5>\n<p>Donnez les lignes de code permettant :<\/p>\n<ul>\n<li>De cr\u00e9er dans le tas une instance de <code>string<\/code> contenant la chaine <code>&quot;aaaaa&quot;<\/code>, point\u00e9e par une variable <code>s<\/code> situ\u00e9e dans la pile.<\/li>\n<li>De concat\u00e9ner la chaine <code>&quot;bbb&quot;<\/code> \u00e0 la chaine point\u00e9e par <code>s<\/code> et de placer le r\u00e9sultat dans une variable <code>t<\/code> de type <code>string<\/code> situ\u00e9e dans la pile.<\/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\">    string* s = new string(&quot;aaaaa&quot;);\n    string t = *s + &quot;bbb&quot;;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3>G.dec2 :  Classes monolithiques<\/h3>\n<h4>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Section G.dec1, Parties A et C<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Rassembler dans une &quot;capsule&quot; plusieurs donn\u00e9es et des m\u00e9thodes permettant d&rsquo;agir sur ces donn\u00e9es.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Dans les langages de programmation proc\u00e9duraux, tels que le langage C, on peut regrouper plusieurs informations dans des structures de donn\u00e9es telles que des tableaux et des structures. Des fonctions ou proc\u00e9dures permettent d&rsquo;exploiter les donn\u00e9es ainsi repr\u00e9sent\u00e9es.<\/p>\n<p>Le concept de programmation orient\u00e9e objet permet de regrouper des structures de donn\u00e9es et l&rsquo;impl\u00e9mentation d&rsquo;algorithmes permettant de traiter, manipuler, utiliser ces donn\u00e9es dans des &quot;capsules&quot; appel\u00e9e <strong>classes<\/strong>. Cette approche simplifie la programmation et permet de produire du code source r\u00e9utilisable, plus facile \u00e0 faire \u00e9voluer que celui des langages purement proc\u00e9duraux.<\/p>\n<h4>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>D\u00e9finir des classes<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Commen\u00e7ons par un premier exemple : la <strong>d\u00e9claration<\/strong> d&rsquo;une classe <code>Point<\/code> permettant de repr\u00e9senter des points appartenant \u00e0 un espace \u00e0 deux dimensions.<\/p>\n<pre><code class=\"language-c++\">class Point\n{\n    private:\n    \/\/ Attributs\n    double x;\n    double y;\n    \n    public:\n    \/\/ Constructeurs\n    Point();\n    Point(double x, double y);\n  \n    \/\/ M\u00e9thodes d'acc\u00e8s\n    void setX(double x);\n    void setY(double Y);\n    double getX();\n    double getY();\n  \n    \/\/ M\u00e9thode d'affichage\n    void affiche();\n};\n<\/code><\/pre>\n<p>Cette d\u00e9claration ne d\u00e9finit pas compl\u00e8tement la classe, mais elle donne des informations importantes, \u00e0 savoir que la classe <code>Point<\/code> comporte :<\/p>\n<ul>\n<li>Deux <strong>attributs priv\u00e9s<\/strong> <code>x<\/code> et <code>y<\/code> de type <code>double<\/code>. Il s&rsquo;agit des donn\u00e9es de toute instance de la classe. Ces attributs ont un r\u00f4le similaire \u00e0 celui des champs d&rsquo;une structure en langage C. Parce qu&rsquo;ils sont priv\u00e9s (mot cl\u00e9 <code>private<\/code>), seules les m\u00e9thodes de la classe <code>Point<\/code> peuvent acc\u00e9der \u00e0 ces attributs.<\/li>\n<li>Deux <strong>constructeur publiques<\/strong> qui permettront d&rsquo;initialiser les instances de <code>Point<\/code> lors de leur cr\u00e9ation. L&rsquo;un des constructeurs n&rsquo;a pas de param\u00e8tre. C&rsquo;est un <strong>constructeur par d\u00e9faut<\/strong>. L&rsquo;autre a pour param\u00e8tres les coordonn\u00e9es du point qui sera repr\u00e9sent\u00e9 par l&rsquo;instance construite.<\/li>\n<li>Des <strong>m\u00e9thodes d&rsquo;acc\u00e8s<\/strong> qui permettent de lire et de modifier les valeurs des attributs. Ces m\u00e9thodes, contrairement aux attributs, sont <strong>publiques<\/strong>. Elle sont utilisables par des m\u00e9thodes membres d&rsquo;autres classes et par des fonctions n&rsquo;appartenant \u00e0 aucune classe.<\/li>\n<li>Une m\u00e9thode <code>affiche<\/code> qui permettra d&rsquo;afficher le contenu d&rsquo;une instance de <code>Point<\/code>.<\/li>\n<\/ul>\n<p>Apr\u00e8s avoir d\u00e9clar\u00e9 la classe, il nous faut d\u00e9finir ses constructeur et ses m\u00e9thodes.<\/p>\n<pre><code class=\"language-C\">Point::Point()\n{\n    this-&gt;x = 0.0;\n    this-&gt;y = 0.0;\n}\n\nPoint::Point(double x, double y)\n{\n    this-&gt;x = x;\n    this-&gt;y = y;\n}\n\nvoid Point::setX(double val) \n{\n    this-&gt;x = val;\n}\n\nvoid Point::setY(double val)\n{\n    this-&gt;y = val;\n}\n\ndouble Point::getX()\n{\n    return x;\n}\n\ndouble Point::getY()\n{\n    return y;\n}\n\nvoid Point::affiche()\n{\n    cout &lt;&lt; &quot;(&quot; &lt;&lt; x &lt;&lt; &quot;,&quot; &lt;&lt; y &lt;&lt; &quot;)&quot;;\n}\n<\/code><\/pre>\n<p>Dans un projet constitu\u00e9 de plusieurs fichiers, la d\u00e9claration de la classe doit \u00eatre plac\u00e9e dans un fichier d&rsquo;ent\u00eate qui pourrait \u00eatre nomm\u00e9 <code>Point.h<\/code> et les d\u00e9finitions de ses constructeurs, destructeur (non n\u00e9cessaire dans notre exemple) et m\u00e9thodes doivent \u00eatre plac\u00e9es dans un fichier qui pourrait \u00eatre nomm\u00e9 <code>Point.cpp<\/code>. Mais dans un projet minimaliste, il est possible de placer la d\u00e9claration et les d\u00e9finitions dans un m\u00eame fichier.<\/p>\n<p>Dans le <strong>constructeur par d\u00e9faut<\/strong> (sans param\u00e8tre), la notation <code>this-&gt;x<\/code> est utilis\u00e9e. Le mot cl\u00e9 <code>this<\/code> repr\u00e9sente l&rsquo;adresse l&rsquo;instance en cours de construction, et <code>this-&gt;x<\/code> permet donc d&rsquo;acc\u00e9der \u00e0 l&rsquo;attribut <code>x<\/code> de l&rsquo;instance en cours de construction. On aurait pu \u00e9crire <code>x = 0.0<\/code> \u00e0 la place de <code>this-&gt;x = 0.0<\/code>.<\/p>\n<p>Dans le <strong>constructeur \u00e0 deux param\u00e8tres<\/strong>, on retrouve les notations <code>this-&gt;x<\/code> et <code>this-&gt;y<\/code>, mais ici elles sont n\u00e9cessaires pour distinguer les attributs des param\u00e8tres du constructeur qui ont les m\u00eames noms.<\/p>\n<p>La lecture des d\u00e9finitions des m\u00e9thodes devrait vous permettre d&rsquo;en comprendre les r\u00f4les.<\/p>\n<p>Voici un exemple d&rsquo;utilisation de la classe <code>Point<\/code> et de ses m\u00e9thodes.<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    Point w(1.0, 2.0);                \/\/ Ligne A\n    w.affiche();                      \/\/ Ligne B\n    cout &lt;&lt; endl &lt;&lt; w.getX() &lt;&lt; endl; \/\/ Ligne C\n    w.setY(3.0);                      \/\/ Ligne D\n    w.affiche();                      \/\/ Ligne E\n    return 0;\n}\n<\/code><\/pre>\n<p><strong>En ligne A<\/strong>, on cr\u00e9e une instance de <code>Point<\/code> situ\u00e9e sur la pile dans une variable w.<\/p>\n<p><strong>En ligne B<\/strong>, on appelle la m\u00e9thode d&rsquo;instance <code>affiche<\/code> de la classe <code>Point<\/code> pour afficher le contenu de <code>w<\/code>.<\/p>\n<p><strong>En ligne C<\/strong>, on r\u00e9cup\u00e8re la coordonn\u00e9e <code>x<\/code> du point repr\u00e9sent\u00e9 par <code>w<\/code> et on l&rsquo;affiche.<\/p>\n<p><strong>En ligne D<\/strong>, on modifie la coordonn\u00e9e <code>y<\/code> du point repr\u00e9sent\u00e9 par <code>w<\/code>.<\/p>\n<p>Les affichages obtenus sont :<\/p>\n<pre><code>(1,2)\n1\n(1,3)\n<\/code><\/pre>\n<h5>Exercice de d\u00e9couverte G.dec.x2<\/h5>\n<p>Donnez les lignes de code permettant de cr\u00e9er une instance de <code>Point<\/code> situ\u00e9e dans le tas en utilisant le constructeur par d\u00e9faut, puis d&rsquo;assigner la valeur 5.0 \u00e0 la coordonn\u00e9e <code>y<\/code> de du point repr\u00e9sent\u00e9 par cette instance, et enfin d&rsquo;afficher ce point.<\/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\">    Point* p = new Point();\n    p-&gt;setY(5.0);\n    p-&gt;affiche();\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Nous allons maintenant ajouter une nouvelle m\u00e9thode permettant de d\u00e9terminer le point situ\u00e9 au milieu du segment d\u00e9termin\u00e9 par deux points. Voici une premi\u00e8re version :<\/p>\n<pre><code class=\"language-C\">Point Point::milieu(Point autre)\n{\n    double mx = (this-&gt;x + autre.x) \/ 2.0;\n    double my = (this-&gt;y + autre.y) \/ 2.0;\n    return Point(mx,my);\n}\n<\/code><\/pre>\n<p>Et voici une deuxi\u00e8me version qui a l&rsquo;avantage d&rsquo;\u00eatre ind\u00e9pendante de la repr\u00e9sentation des points. Si par exemple les attributs priv\u00e9s repr\u00e9sentaient un point en coordonn\u00e9es polaires et que les m\u00e9thodes d&rsquo;acc\u00e8s \u00e9taient modifi\u00e9e de mani\u00e8re \u00e0 retourner les coordonn\u00e9es cart\u00e9siennes, aucun changement ne serait n\u00e9cessaire dans la d\u00e9finition de la m\u00e9thode <code>milieu<\/code>.<\/p>\n<pre><code class=\"language-C\">Point Point::milieu(Point autre)\n{\n    double mx = (this-&gt;getX() + autre.getX()) \/ 2.0;\n    double my = (this-&gt;getY() + autre.getY()) \/ 2.0;\n    return Point(mx,my);\n}\n<\/code><\/pre>\n<h5>Exercice de d\u00e9couverte G.dec.x3<\/h5>\n<p>Donnez les lignes de code permettant de cr\u00e9er deux instances de <code>Point<\/code> dans la pile, puis de cr\u00e9er une instance de <code>Point<\/code> repr\u00e9sentant le milieu du segment d\u00e9limit\u00e9 par les deux premiers points, puis d&rsquo;afficher le r\u00e9sultat.<\/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\">    Point a(1.0,1.0);\n    Point b(0.0,2.0);\n    Point c = a.milieu(b);\n    c.affiche();\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Il y a une petite singularit\u00e9 syntaxique lors de la cr\u00e9ation d&rsquo;une instance de classe dans la pile avec un constructeur par d\u00e9faut. Examinons l&rsquo;exemple suivant :<\/p>\n<pre><code class=\"language-c\">    Point p1;                        \/\/ Ligne A\n    Point* p2 = new Point();         \/\/ Ligne B\n    Point p3(1.0, 1.0);              \/\/ Ligne C\n    Point* p4 = new Point(1.0, 1.0); \/\/ Ligne D\n<\/code><\/pre>\n<p>Cette singularit\u00e9 se situe sur la <strong>ligne A<\/strong>, qui cr\u00e9e une instance de <code>Point<\/code> situ\u00e9e dans la pile. Il n&rsquo;y a pas de parenth\u00e8ses, alors que lors de la cr\u00e9ation d&rsquo;une instance similaire dans le tas, <strong>ligne B<\/strong>, il y a des parenth\u00e8ses. Dans le cas de l&rsquo;utilisation d&rsquo;un constructeur avec param\u00e8tres, il y a toujours des parenth\u00e8ses.<\/p>\n<h4>Compl\u00e9ment<\/h4>\n<p>Si aucun constructeur n&rsquo;est d\u00e9finit pour une classe, cette classe est pourvue d&rsquo;un constructeur par d\u00e9faut implicite (invisible dans le code). Ce constructeur par d\u00e9faut n&rsquo;initialise pas les attributs de types primitifs tels que <code>int<\/code> et <code>double<\/code>. Il est toutefois possible de donner des valeurs d&rsquo;initialisation aux attributs en utilisant la syntaxe suivante :<\/p>\n<pre><code class=\"language-c++\">class Point\n{\n    private:\n    double x{0.0};\n    double y{0.0};\n  \n    \/\/ etc.\n};\n<\/code><\/pre>\n<p>D\u00e8s lors qu&rsquo;au moins un constructeur est d\u00e9finit, m\u00eame s&rsquo;il ne s&rsquo;agit pas d&rsquo;un constructeur par d\u00e9faut (c&rsquo;est \u00e0 dire sans param\u00e8tre), il n&rsquo;y a plus de constructeur par d\u00e9faut implicite. Si un tel constructeur est n\u00e9cessaire, alors il faut le d\u00e9finir explicitement.<\/p>\n<h3>G.dec3 : R\u00e9f\u00e9rences<\/h3>\n<h4>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Section G.dec1 et G.dec2<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Optimiser l&rsquo;efficacit\u00e9 des m\u00e9thodes et constructeurs exploitant des instances de classes<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Comme les structures du langage C, les classes du C++ supportent nativement le passage en param\u00e8tres par copie et l&rsquo;assignation avec l&rsquo;op\u00e9rateur <code>=<\/code>. Mais la copie d&rsquo;une instance de classe peut prendre plus de temps CPU et consommer plus de m\u00e9moire que la copie de son adresse.<\/p>\n<p>Il est possible d&rsquo;optimiser l&rsquo;efficacit\u00e9 de certaines m\u00e9thodes en leur passant en param\u00e8tres des pointeurs sur des instances de classe plut\u00f4t que des instances de classes, comme cela peut se pratiquer en C avec les structures et les fonctions, mais il y a une autre possibilit\u00e9 en C++.<\/p>\n<h4>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Les r\u00e9f\u00e9rences<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Une <strong>r\u00e9f\u00e9rence<\/strong> est un pointeur cach\u00e9. Pointeur parce qu&rsquo;en m\u00e9moire, un r\u00e9f\u00e9rence est repr\u00e9sent\u00e9e par un pointeur, cach\u00e9 parce qu&rsquo;\u00e0 l&rsquo;utilisation, la syntaxe est identique \u00e0 celle d&rsquo;un passage de param\u00e8tre par copie ou d&rsquo;une assignation d&rsquo;instance de classe.<\/p>\n<p>Examinons un exemple bas\u00e9 sur la m\u00e9thode <code>milieu<\/code> de la classe <code>Point<\/code> de la section pr\u00e9c\u00e9dente, que nous renommons <code>milieu1<\/code> :<\/p>\n<pre><code class=\"language-C\">Point Point::milieu1(Point autre)\n{\n    double mx = (this-&gt;getX() + autre.getX()) \/ 2.0;\n    double my = (this-&gt;getY() + autre.getY()) \/ 2.0;\n    return Point(mx,my);\n}\n<\/code><\/pre>\n<p>Il est possible de r\u00e9aliser une version avec passage du param\u00e8tre par pointeur :<\/p>\n<pre><code class=\"language-C\">Point Point::milieu2(Point* autre)\n{\n    double mx = (this-&gt;getX() + autre-&gt;getX()) \/ 2.0;\n    double my = (this-&gt;getY() + autre-&gt;getY()) \/ 2.0;\n    return Point(mx,my);\n}\n<\/code><\/pre>\n<p>Mais ont peut aussi r\u00e9aliser une troisi\u00e8me version utilisant le <strong>passage de param\u00e8tre par r\u00e9f\u00e9rence<\/strong> :<\/p>\n<pre><code class=\"language-C\">Point Point::milieu(Point&amp; autre)\n{\n    double mx = (this-&gt;getX() + autre.getX()) \/ 2.0;\n    double my = (this-&gt;getY() + autre.getY()) \/ 2.0;\n    return Point(mx,my);\n}\n<\/code><\/pre>\n<p>Observez attentivement les diff\u00e9rences dans le code des trois variantes. L&rsquo;esperluette <code>&amp;<\/code> de la troisi\u00e8me version \u00e0 une signification nouvelle. Elle dit que le param\u00e8tre <code>autre<\/code> est une <strong>r\u00e9f\u00e9rence<\/strong> d&rsquo;instance de <code>Point<\/code>. Cette r\u00e9f\u00e9rence d\u00e9signe une variable de type <code>Point<\/code> et s&rsquo;utilise comme telle.<\/p>\n<p>Examinons \u00e0 pr\u00e9sent l&rsquo;utilisation de ces trois variantes :<\/p>\n<pre><code class=\"language-c++\">    Point a(1.0,1.0);\n    Point b(2.0,3.0);\n    Point m1 = a.milieu1(b);  \/\/ Ligne A\n    Point m2 = a.milieu2(&amp;b); \/\/ Ligne B\n    Point m3 = a.milieu(b);  \/\/ Ligne C\n    m1.affiche();\n    m2.affiche();\n    m3.affiche();\n<\/code><\/pre>\n<p><strong>En ligne A<\/strong>, on passe en param\u00e8tre une <strong>copie<\/strong> de l&rsquo;instance de <code>Point<\/code> contenue dans la variable <code>b<\/code>. Cette instance et sa copie ont chacune une taille de 16 octets.<\/p>\n<p><strong>En ligne B<\/strong>, on passe en param\u00e8tre <strong>l&rsquo;adresse<\/strong> de la variable <code>b<\/code>. Sur la machine utilis\u00e9e pour mes essais, cette adresse a une taille de 8 octets.<\/p>\n<p><strong>En ligne C<\/strong>, on passe en param\u00e8tre la <strong>r\u00e9f\u00e9rence<\/strong> de la variable <code>b<\/code>. La r\u00e9f\u00e9rence est en fait l&rsquo;adresse de la variable, mais la syntaxe de l&rsquo;appel est identique \u00e0 celle utilis\u00e9e pour un param\u00e8tre pass\u00e9 par copie.<\/p>\n<p>En r\u00e9sum\u00e9, la variante avec passage de param\u00e8tre par r\u00e9f\u00e9rence est aussi efficace que celle avec passage par pointeur, mais avec une <strong>syntaxe simplifi\u00e9e<\/strong> : pas d&rsquo;esperluette lors de l&rsquo;appel, pas de fl\u00e8che pour l&rsquo;acc\u00e8s aux m\u00e9thodes d&rsquo;instance du param\u00e8tre dans le code de la m\u00e9thode.<\/p>\n<h5>Exercice de d\u00e9couverte G.dec.x4<\/h5>\n<p>Donnez les lignes de code permettant de cr\u00e9er deux instances de <code>Point<\/code> dans le tas et d&rsquo;utiliser la m\u00e9thode <code>milieu<\/code> pour produire le milieu du segment d\u00e9limit\u00e9 par ces deux points et placer le r\u00e9sultat dans une variable <code>m<\/code> situ\u00e9e dans la pile. N&rsquo;oubliez pas qu&rsquo;\u00e0 l&rsquo;utilisation, une m\u00e9thode qui accepte un param\u00e8tre par r\u00e9f\u00e9rence s&rsquo;utilise comme une m\u00e9thode qui accepterait ce param\u00e8tre par copie.<\/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\">    Point* a = new Point(1.0,1.0);\n    Point* b = new Point(2.0,3.0);\n    Point m = a-&gt;milieu(*b);\n<\/code><\/pre>\n<p>Il ne fallait pas oublier :<\/p>\n<ul>\n<li>L&rsquo;utilisation de <code>new<\/code> pour cr\u00e9er des instances dans le tas.<\/li>\n<li>Que <code>new<\/code> retourne un pointeur vers l&rsquo;instance construite.<\/li>\n<li>Que l&rsquo;appel d&rsquo;une m\u00e9thode d&rsquo;instance via l&rsquo;adresse de cette instance n\u00e9cessite l&rsquo;utilisation de la fl\u00e8che <code>-&gt;<\/code>.<\/li>\n<li>Que le passage en param\u00e8tre par copie, ou par r\u00e9f\u00e9rence, d&rsquo;une instance <strong>via son adresse<\/strong> n\u00e9cessite une d\u00e9pointage.<\/li>\n<\/ul>\n<p><\/div>\n\t\t\t<\/div>\n<p>Tout ceci peut paraitre obscur et compliqu\u00e9 en premi\u00e8re lecture, mais c&rsquo;est en fait d&rsquo;une extr\u00eame coh\u00e9rence. Il faut simplement prendre le temps de comprendre et d&rsquo;assimiler chaque concept, un par un. N&rsquo;h\u00e9sitez pas \u00e0 faire vos propres essais sur machine, \u00e0 inventer vos propres exp\u00e9riences.<\/p>\n<hr>\n<h4>Compl\u00e9ment<\/h4>\n<table>\n<thead>\n<tr>\n<th>Compl\u00e9ment sur les r\u00e9f\u00e9rences<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>L&rsquo;utilisation des r\u00e9f\u00e9rences n&rsquo;est pas limit\u00e9e aux param\u00e8tres de m\u00e9thodes ou fonctions. Une m\u00e9thode d&rsquo;instance peut retourner la r\u00e9f\u00e9rence d&rsquo;un attribut de la classe \u00e0 laquelle elle appartient (des exemples seront donn\u00e9 dans la partie G.ent.). Par contre, une m\u00e9thode ne peut pas retourner la r\u00e9f\u00e9rence d&rsquo;une de ses variables locales, puisqu&rsquo;une telle variable n&rsquo;existe plus lorsque l&rsquo;ex\u00e9cution de la fonction dans laquelle elle est d\u00e9clar\u00e9e se termine.<\/p>\n<p>Des variables de type r\u00e9f\u00e9rence peuvent par ailleurs \u00eatre d\u00e9clar\u00e9es et utilis\u00e9es. Voici un exemple :<\/p>\n<pre><code class=\"language-C\">void exemple()\n{\n    Point a(1.0,1.0); \/\/ Ligne A\n    Point&amp; b = a;     \/\/ Ligne B\n    b.setY(2.0);      \/\/ Ligne C\n    a.affiche();\n    b.affiche();\n}\n<\/code><\/pre>\n<p><strong>En ligne A<\/strong>, la variable <code>a<\/code> est initialis\u00e9e avec une instance de <code>Point<\/code>.<\/p>\n<p><strong>En ligne B<\/strong>, la variable <code>b<\/code>, de type r\u00e9f\u00e9rence sur <code>Point<\/code>, est initialis\u00e9e avec la r\u00e9f\u00e9rence de <code>a<\/code>.<\/p>\n<p><strong>En ligne C<\/strong>, on modifie l&rsquo;instance de <code>Point<\/code> r\u00e9f\u00e9renc\u00e9e par <code>b<\/code>.<\/p>\n<p>\u00c0 l&rsquo;ex\u00e9cution, on obtient l&rsquo;affichage :<\/p>\n<pre><code>(1,2) (1,2)\n<\/code><\/pre>\n<p>Cette modification a impact\u00e9 l&rsquo;instance de <code>Point<\/code> situ\u00e9e dans la variable <code>a<\/code> car <code>a<\/code> et <code>b<\/code> d\u00e9signent la m\u00eame instance.<\/p>\n<h3>G.dec4 :  Classes compos\u00e9es<\/h3>\n<h4>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Sections G.dec1, G.dec2, G.dec3<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Mod\u00e9liser et exploiter des donn\u00e9es complexes structur\u00e9es en plusieurs blocs<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>D\u00e9finir des classes ayant des attributs de type classe<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Voici la d\u00e9claration d&rsquo;une classe permettant de repr\u00e9senter des segments constitu\u00e9s de 2 points.<\/p>\n<pre><code class=\"language-c++\">class Segment\n{\n    private:\n    Point a;\n    Point b;\n    \n    public:\n    Segment(Point&amp; deb, Point&amp; fin);\n    Segment(double x1, double y1, double x2, double y2);\n    \n    Point milieu();\n    void affiche();\n};\n<\/code><\/pre>\n<p>Les attributs <code>a<\/code> et <code>b<\/code>, repr\u00e9sentant les extr\u00e9mit\u00e9s d&rsquo;un segment, sont des instances de <code>Point<\/code>.<\/p>\n<p>Deux constructeurs sont d\u00e9clar\u00e9s, un permettant l&rsquo;initialisation du segment cr\u00e9\u00e9 avec des instances de <code>Point<\/code> pass\u00e9e par r\u00e9f\u00e9rences, et un autre acceptant en param\u00e8tre les coordonn\u00e9es, de type <code>double<\/code>, des deux extr\u00e9mit\u00e9s.<\/p>\n<p>Une m\u00e9thode <code>milieu<\/code> devra retourner l&rsquo;instance de <code>Point<\/code> repr\u00e9sentant le milieu d&rsquo;un segment et une m\u00e9thode <code>affiche<\/code> permettra l&rsquo;affichage d&rsquo;une instance de <code>Segment<\/code>.<\/p>\n<p>Des m\u00e9thodes d&rsquo;acc\u00e8s pourraient \u00eatre ajout\u00e9es.<\/p>\n<p>Voici la d\u00e9finition du premier constructeur :<\/p>\n<pre><code class=\"language-c++\">Segment::Segment(Point&amp; deb, Point&amp; fin) : \na(deb), b(fin)\n{\n}\n<\/code><\/pre>\n<p>La syntaxe utilis\u00e9e ici est nouvelle et diff\u00e9rente de celle vue avec la classe <code>Point<\/code>. Les attributs <code>a<\/code> et <code>b<\/code> ne sont pas initialis\u00e9s dans le corps du constructeur, mais par une <strong>liste d&rsquo;initialisation<\/strong> qui fait appel au constructeur en copie implicite de la classe <code>Point<\/code>.<\/p>\n<p>La notation <code>a(deb)<\/code> signifie que l&rsquo;attribut <code>a<\/code> est initialis\u00e9 avec une copie de l&rsquo;instance de <code>Point<\/code> d\u00e9sign\u00e9e par <code>deb<\/code>.<\/p>\n<p>Il est possible d&rsquo;initialiser les deux attributs dans le corps du constructeur comme ceci :<\/p>\n<pre><code class=\"language-c++\">Segment::Segment(Point&amp; deb, Point&amp; fin)\n{\n    a = deb;\n    b = fin;\n}\n<\/code><\/pre>\n<p>Mais cette forme est d\u00e9conseill\u00e9e pour l&rsquo;initialisation d&rsquo;attributs de type classe car elle peut entra\u00eener, dans certaines situations, une perte de performance, bien que ce ne soit pas le cas ici.<\/p>\n<hr>\n<p>Voici la d\u00e9finition du deuxi\u00e8me constructeur :<\/p>\n<pre><code class=\"language-c++\">Segment::Segment(double x1, double y1, double x2, double y2) :\na(Point(x1,y1)), b(Point(x2,y2))\n{\n}\n<\/code><\/pre>\n<p>Ici encore, une liste d&rsquo;initialisation est utilis\u00e9e pour initialiser les attributs repr\u00e9sentant les extr\u00e9mit\u00e9s du segment par appel du constructeur \u00e0 deux param\u00e8tres de la classe <code>Point<\/code>. L&rsquo;initialisation des attributs dans le corps du constructeur serait possible, mais entrainerait dans ce cas une perte d&rsquo;efficacit\u00e9. En effet, si on \u00e9crit&#8230;<\/p>\n<pre><code class=\"language-c++\">Segment::Segment(double x1, double y1, double x2, double y2) \n{\n    this-&gt;a = Point(x1,y1);\n    this-&gt;b = Point(x2,y2);\n}\n<\/code><\/pre>\n<p>&#8230; alors par exemple lors de l&rsquo;initialisation de l&rsquo;attribut <code>a<\/code>, une instance de <code>Point<\/code> est cr\u00e9\u00e9e par le constructeur \u00e0 deux param\u00e8tres de la classe <code>Point<\/code>, puis recopi\u00e9e dans l&rsquo;attribut par l&rsquo;op\u00e9rateur d&rsquo;assignation <code>=<\/code>, puis d\u00e9truite (alors que sa copie reste dans l&rsquo;attribut <code>a<\/code>). Avec l&rsquo;utilisation d&rsquo;une liste d&rsquo;initialisation, le constructeur de la classe <code>Point<\/code> cr\u00e9e directement une instance dans l&rsquo;attribut <code>a<\/code>.<\/p>\n<p>Ne vous inqui\u00e9tez pas si vous ne saisissez pas la nuance entre le fonctionnement des deux variantes. Par contre, retenez que lorsque les attributs contiennent des <strong>instances de classe<\/strong>, l&rsquo;utilisation d&rsquo;une liste d&rsquo;initialisation est pr\u00e9f\u00e9rable et conseill\u00e9e.<\/p>\n<hr>\n<p>Voici la d\u00e9finition de la m\u00e9thode <code>milieu<\/code> de la classe <code>Segment<\/code> qui fait appel \u00e0 la m\u00e9thode <code>milieu<\/code> pr\u00e9alablement d\u00e9finie dans la classe <code>Point<\/code>.<\/p>\n<pre><code class=\"language-c++\">Point Segment::milieu()\n{\n    return a.milieu(b);\n}\n<\/code><\/pre>\n<hr>\n<h5>Exercice de d\u00e9couverte G.dec.x5<\/h5>\n<p>D\u00e9finissez la m\u00e9thode <code>Segment::affiche()<\/code> sachant que l&rsquo;ex\u00e9cution des lignes de code suivantes&#8230;<\/p>\n<pre><code class=\"language-c++\">    Segment s1(1.0, 2.0, 3.0, 4.0);\n    s1.affiche();\n<\/code><\/pre>\n<p>&#8230;doit produire l&rsquo;affichage :<\/p>\n<pre><code>[(1,2),(3,4)]\n<\/code><\/pre>\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 Segment::affiche()\n{\n    cout &lt;&lt; &quot;[&quot;;\n    a.affiche();\n    cout &lt;&lt; &quot;,&quot;;\n    b.affiche();\n    cout &lt;&lt; &quot;]&quot; &lt;&lt; endl;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4>Compl\u00e9ment<\/h4>\n<p>Telle que d\u00e9finie pr\u00e9c\u00e9demment, la classe <code>Segment<\/code> n&rsquo;a pas de constructeur par d\u00e9faut, ni implicite, ni explicite. La pr\u00e9sence d&rsquo;autres constructeurs annule l&rsquo;existence d&rsquo;un constructeur par d\u00e9faut implicite. On peut bien sur ajouter un constructeur par d\u00e9faut explicite. Celui-ci permet d&rsquo;initialiser les deux attributs avec le constructeur par d\u00e9faut de la classe <code>Segment<\/code> :<\/p>\n<pre><code class=\"language-c++\">Segment::Segment()\n{\n}\n<\/code><\/pre>\n<p>Il n&rsquo;est pas n\u00e9cessaire de mettre du code car les attributs de type classe (dans ce cas particulier, la classe <code>Point<\/code>) sont initialis\u00e9s implicitement avec les constructeur par d\u00e9faut de leur classe.<\/p>\n<p>On pourrait \u00e9galement \u00e9crire :<\/p>\n<pre><code class=\"language-c++\">Segment::Segment() :\na(), b()\n{\n}\n<\/code><\/pre>\n<h3>G.dec5 :  La classe standard vector<\/h3>\n<h4>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Sections pr\u00e9c\u00e9dentes : G.dec1 \u00e0 G.dec4<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Exploiter des listes ordonn\u00e9es de donn\u00e9es d&rsquo;un m\u00eame type<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>En langage C comme dans de nombreux autres langages de programmation, les tableaux permettent de repr\u00e9senter des listes de donn\u00e9es de m\u00eame types et d&rsquo;acc\u00e9der \u00e0 ces donn\u00e9es \u00e0 l&rsquo;aide d&rsquo;un indice qui indique leurs position dans la liste.<\/p>\n<p>Nous avons vu que les tableaux du langage C sont tr\u00e8s rudimentaires puisqu&rsquo;ils sont impl\u00e9ment\u00e9s comme de simples blocs m\u00e9moire accessibles via des pointeurs. L&rsquo;utilisation de tels tableaux est tr\u00e8s peu s\u00e9curis\u00e9e et comporte certaines limitations, telle que l&rsquo;impossibilit\u00e9 de copier directement le contenu d&rsquo;un tableau dans un autre avec l&rsquo;op\u00e9rateur d&rsquo;assignation <code>=<\/code>.<\/p>\n<p>Un moyen plus s\u00fbr et plus pratique pour repr\u00e9senter et exploiter une collection de donn\u00e9es de m\u00eame type serait bienvenu.<\/p>\n<h4>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>La classe standard std::vector<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Les instances de la classe standard <code>std::vector<\/code> repr\u00e9sentent des listes de valeurs d&rsquo;un m\u00eame type scalaire (<code>int<\/code>, <code>double<\/code> etc.) ou d&rsquo;instances d&rsquo;une m\u00eame classe. Contrairement \u00e0 un tableau, une liste repr\u00e9sent\u00e9e par un vecteur est extensible. On peut augmenter sa taille en ins\u00e9rant de nouveaux \u00e9l\u00e9ments \u00e0 la fin, au d\u00e9but ou au milieu.<\/p>\n<p><strong>Remarque importante<\/strong> : Toutes les possibilit\u00e9s et toutes les subtilit\u00e9s de la classe <code>std::vector<\/code> ne seront pas pr\u00e9sent\u00e9es. Par exemple, les it\u00e9rateurs et l&rsquo;insertion d&rsquo;\u00e9l\u00e9ments dans un vecteur ne seront pas abord\u00e9s.<\/p>\n<p>Voici un exemple de d\u00e9clarations de vecteurs d&rsquo;instances de <code>Points<\/code>.<\/p>\n<pre><code class=\"language-C++\">    Point w(1.0,2.0);\n    vector&lt;Point&gt; v1;      \/\/ Ligne A\n    vector&lt;Point&gt; v2(5);   \/\/ Ligne B\n    vector&lt;Point&gt; v3(3,w); \/\/ Ligne C\n<\/code><\/pre>\n<p><strong>En ligne A<\/strong>, un vecteur vide est cr\u00e9\u00e9 dans la pile. En r\u00e9alit\u00e9, l&rsquo;instance cr\u00e9\u00e9e comporte une ramification dans le tas, mais qui est compl\u00e8tement transparente lors de l&rsquo;utilisation, c&rsquo;est \u00e0 dire qu&rsquo;elle se comporte comme une instance de classe monolithique qui serait enti\u00e8rement stock\u00e9e dans la pile. En particulier, la m\u00e9moire occup\u00e9e par sa ramification dans le tas sera automatiquement lib\u00e9r\u00e9e lorsque la variable <code>v1<\/code> sera d\u00e9truite.<\/p>\n<p><strong>En ligne B<\/strong>, un vecteur contenant 5 instances de <code>Point<\/code> est cr\u00e9\u00e9. Chacune des instances plac\u00e9es dans le vecteur est initialis\u00e9e avec le constructeur par d\u00e9faut de la classe <code>Point<\/code>. Si la classe <code>Point<\/code> n&rsquo;avait pas de constructeur par d\u00e9faut, une erreur serait produite \u00e0 la compilation.<\/p>\n<p><strong>En ligne C<\/strong>, un vecteur contenant 3 copies de l&rsquo;instance de <code>Point<\/code> contenue dans la variable <code>w<\/code> est cr\u00e9\u00e9e.<\/p>\n<hr>\n<p>Il est \u00e9galement possible d&rsquo;initialiser une instance de vecteur en utilisant des accolades, comme pour un tableau. Voici deux exemples qui ont exactement le m\u00eame effet : cr\u00e9er une instance de <code>vector<\/code> contenant deux points.<\/p>\n<pre><code class=\"language-c++\">    vector&lt;Point&gt; vec1{{1.0,1.0}, {2.0,3.0}};\n    vector&lt;Point&gt; vec2{Point(1.0,1.0), Point(2.0,3.0)};\n<\/code><\/pre>\n<hr>\n<p>Nous allons maintenant voir comment <strong>ajouter<\/strong> des \u00e9l\u00e9ments \u00e0 la fin d&rsquo;un vecteur et comment <strong>retirer<\/strong> l&rsquo;\u00e9l\u00e9ment situ\u00e9 en fin d&rsquo;un vecteur. Chacune de ces op\u00e9rations change la taille du vecteur, qui peut \u00eatre obtenue gr\u00e2ce \u00e0 la m\u00e9thode <code>size<\/code>.<\/p>\n<pre><code class=\"language-c++\">    v1.push_back(w);            \/\/ Ligne A\n    v2.pop_back();              \/\/ Ligne B\n    v2.push_back(w);            \/\/ Ligne C\n    cout &lt;&lt; v1.size() &lt;&lt; endl;\n    cout &lt;&lt; v2.size() &lt;&lt; endl;\n<\/code><\/pre>\n<p><strong>En ligne A<\/strong>, une copie de l&rsquo;instance de <code>Point<\/code> situ\u00e9e dans la variable <code>w<\/code> est ajout\u00e9e \u00e0 la fin du vecteur situ\u00e9 dans la variable <code>v1<\/code>.<\/p>\n<p><strong>En ligne B<\/strong>, le dernier \u00e9l\u00e9ment du vecteur situ\u00e9 dans la variable <code>v2<\/code> est supprim\u00e9.<\/p>\n<p><strong>En ligne C<\/strong>, une copie de l&rsquo;instance de <code>Point<\/code> situ\u00e9e dans <code>w<\/code> est ajout\u00e9e \u00e0 la fin du vecteur situ\u00e9 dans la variable <code>v2<\/code>.<\/p>\n<p>Les deux derni\u00e8res lignes affichent les tailles des deux vecteurs :<\/p>\n<pre><code>1\n5\n<\/code><\/pre>\n<h5>Exercice de d\u00e9couverte G.dec.x6<\/h5>\n<p>Donnez la liste de points contenus dans les vecteurs situ\u00e9s dans les variables v1 et v2 \u00e0 l&rsquo;issue de l&rsquo;ex\u00e9cution des lignes de code suivantes :<\/p>\n<pre><code class=\"language-c++\">    Point w(1.0,2.0);\n    vector&lt;Point&gt; v1; \n    vector&lt;Point&gt; v2(5);\n    v1.push_back(w);  \n    v2.pop_back(); \n    v2.push_back(w); \n<\/code><\/pre>\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>Contenu du vecteur situ\u00e9 dans <code>v1<\/code> :<\/p>\n<pre><code>(1.0,2.0)\n<\/code><\/pre>\n<p>Contenu du vecteur situ\u00e9 dans <code>v2<\/code> :<\/p>\n<pre><code>(0.0,0.0),(0.0,0.0),(0.0,0.0),(0.0,0.0),(1.0,2.0)\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>On peut acc\u00e9der aux \u00e9l\u00e9ments d&rsquo;un vecteur en lecture et \u00e9criture avec la m\u00eame notation \u00e0 base de crochets que pour un tableau. Voici un exemple d&rsquo;utilisation dans une fonction ayant pour r\u00f4le d&rsquo;afficher un vecteur de points :<\/p>\n<pre><code class=\"language-c++\">void printVectPoint(vector&lt;Point&gt;&amp; vect)\n{\n    for(int i=0; i&lt;vect.size(); i++)\n    {\n        vect[i].affiche();\n    }\n    cout &lt;&lt; endl;\n}\n<\/code><\/pre>\n<p>Il ne s&rsquo;agit pas d&rsquo;une m\u00e9thode, mais d&rsquo;une fonction n&rsquo;appartenant \u00e0 aucune classe qui accepte en param\u00e8tre la r\u00e9f\u00e9rence d&rsquo;une instance de la classe <code>vector&lt;Point&gt;<\/code>. Le passage par r\u00e9f\u00e9rence est utilis\u00e9 ici pour am\u00e9liorer l&rsquo;efficacit\u00e9. Comme le vecteur n&rsquo;est pas modifi\u00e9, un passage par copie aurait \u00e9t\u00e9 possible.<\/p>\n<h5>Exercice de d\u00e9couverte G.dec.x7<\/h5>\n<p>Donnez les lignes de code permettant d&rsquo;appeler la fonction <code>printVectPoint<\/code> pour afficher les contenus des vecteurs situ\u00e9s dans les variables <code>v1<\/code> et <code>v2<\/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++\">    printVectPoint(v1);\n    printVectPoint(v2);\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<h5>Exercice de d\u00e9couverte G.dec.x8<\/h5>\n<p>Donnez les lignes de code permettant de r\u00e9aliser les actions suivantes :<\/p>\n<ol>\n<li>D\u00e9clarer une variable <code>tab<\/code> contenant un <strong>vecteur d&rsquo;entiers<\/strong> contenant 5 fois la valeur 1,<\/li>\n<li>Ajouter la valeur 2 \u00e0 la fin en utilisant la m\u00e9thode <code>push_back<\/code>,<\/li>\n<li>Remplacer la premi\u00e8re valeur par 3 en utilisant les crochets.<\/li>\n<li>Afficher tous les \u00e9l\u00e9ments du vecteur \u00e0 l&rsquo;aide d&rsquo;une boucle <code>for<\/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<p>Le vecteur est cr\u00e9\u00e9 et initialis\u00e9 par cette d\u00e9claration :<\/p>\n<pre><code class=\"language-c++\">    vector&lt;int&gt; tab(5,1);\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\">&quot;Indice2&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Voici les trois premi\u00e8res lignes. Il manque la boucle d&rsquo;affichage.<\/p>\n<pre><code class=\"language-c++\">    vector&lt;int&gt; tab(5,1);\n    tab.push_back(2);\n    tab[0] = 3;\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\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c++\">    for(int i=0; i&lt;tab.size(); i++)\n    {\n        cout &lt;&lt; tab[i] &lt;&lt; &quot; &quot;;\n    }\n    cout &lt;&lt; endl;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4>Compl\u00e9ments<\/h4>\n<table>\n<thead>\n<tr>\n<th>Quelques m\u00e9thodes utiles de la classe vector<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Nous prendrons comme exemple un vecteur de points :<\/p>\n<pre><code class=\"language-c++\">vector&lt;Point&gt; vec(5);\n<\/code><\/pre>\n<h5>Acc\u00e8s au dernier \u00e9l\u00e9ment d&rsquo;un vecteur :<\/h5>\n<pre><code class=\"language-c++\">reference back();\n<\/code><\/pre>\n<p>Exemple d&rsquo;utilisation :<\/p>\n<pre><code class=\"language-c++\">\/\/ Modifie la coordonn\u00e9e x du dernier point du vecteur\nvect.back().setX(5.3); \n<\/code><\/pre>\n<p>\u00c9quivalent \u00e0 :<\/p>\n<pre><code class=\"language-c++\">vect[vect.size()-1].setX(5.3);\n<\/code><\/pre>\n<h5>Suppression des \u00e9l\u00e9ments d&rsquo;un vecteur<\/h5>\n<pre><code class=\"language-c++\">void clear();\n<\/code><\/pre>\n<p>Exemple d&rsquo;utilisation :<\/p>\n<pre><code class=\"language-c++\">vect.clear();\ncout &lt;&lt; vect.size(); \/\/ Affiche 0\n<\/code><\/pre>\n<h5>Augmentation de la capacit\u00e9<\/h5>\n<p>La taille d&rsquo;un vecteur augmente automatiquement lorsqu&rsquo;on lui ajoute des \u00e9l\u00e9ments, mais cette op\u00e9ration a un certain co\u00fbt. Pour am\u00e9liorer l&rsquo;efficacit\u00e9 de l&rsquo;ajout d&rsquo;\u00e9l\u00e9ments, un vecteur dispose d&rsquo;une capacit\u00e9 de stockage qui peut \u00eatre plus grande que son nombre d&rsquo;\u00e9l\u00e9ments. Quand le nombre d&rsquo;\u00e9l\u00e9ments stock\u00e9s dans un vecteur atteint sa capacit\u00e9, celle-ci est augment\u00e9e automatiquement d&rsquo;une valeur fix\u00e9e par un algorithme interne \u00e0 la classe <code>vector<\/code>.<\/p>\n<p>La m\u00e9thode suivante permet de fixer une capacit\u00e9, ce qui peut permettre d&rsquo;am\u00e9liorer l&rsquo;efficacit\u00e9 des ajouts lorsqu&rsquo;on connait le nombre d&rsquo;\u00e9l\u00e9ments qui seront, \u00e0 terme, stock\u00e9s dans le vecteur.<\/p>\n<pre><code class=\"language-c++\">void reserve(size_type count);\n<\/code><\/pre>\n<p>Exemple d&rsquo;utilisation :<\/p>\n<pre><code class=\"language-c++\">vect.reserve(1000);\n<\/code><\/pre>\n<p>Cette m\u00e9thode n&rsquo;ajoute aucun \u00e9l\u00e9ment au vecteur. Elle r\u00e9serve juste une certaine capacit\u00e9 de stockage pour \u00e9viter une perte de performance due \u00e0 des augmentations successives cette capacit\u00e9.<\/p>\n<h5>Modification de la taille<\/h5>\n<p>La m\u00e9thode suivante modifie la taille d&rsquo;un vecteur, c&rsquo;est \u00e0 dire le nombre d&rsquo;\u00e9l\u00e9ments qu&rsquo;il contient.<\/p>\n<pre><code class=\"language-c++\">void resize(size_type new_size);\nvoid resize(size_type new_size, Type value);\n<\/code><\/pre>\n<p>Dans le cas d&rsquo;un agrandissement, la premi\u00e8re variante utilise le constructeur par d\u00e9faut de la classe des \u00e9l\u00e9ments du vecteur pour initialiser les \u00e9l\u00e9ments ajout\u00e9s, alors que la deuxi\u00e8me variante ajoute des copies de <code>value<\/code>.<\/p>\n<p>Exemple d&rsquo;utilisation :<\/p>\n<pre><code class=\"language-c++\">vect.resize(20);\n<\/code><\/pre>\n<p>Notre vecteur contenait initialement 5 instances de <code>Point<\/code>. Apr\u00e8s redimensionnement, il en contient 20. Les 15 instances de <code>Point<\/code> ajout\u00e9es ont \u00e9t\u00e9 initialis\u00e9es par le constructeur par d\u00e9faut (sans param\u00e8tre) de la classe <code>Point<\/code>.<\/p>\n<h5>Exercice de d\u00e9couverte G.dec.x9<\/h5>\n<p>Donnez la ligne de code permettant d&rsquo;augmenter la taille du vecteur contenu dans la variable <code>vect<\/code> \u00e0 30 en ajoutant des instances de <code>Point<\/code> repr\u00e9sentant des points de coordonn\u00e9es (3.5,5.6). Vous devez utliser la m\u00e9thode <code>resize<\/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++\">Point p(3.5,5.6);\nvect.resize(30,p);\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3>G.dec6 :  Classes ramifi\u00e9es et destructeurs<\/h3>\n<h4>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Sections G.dec1 \u00e0 G.dec6<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>\u00c9viter les fuites m\u00e9moire<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Jusqu&rsquo;\u00e0 maintenant, nous n&rsquo;avons pas impl\u00e9ment\u00e9 de destructeur dans nos classes. La raison est qu&rsquo;un <strong>destructeur implicite<\/strong> est impl\u00e9ment\u00e9 par le compilateur lorsqu&rsquo;aucun destructeur explicite n&rsquo;est ajout\u00e9 \u00e0 une classe. Ce destructeur implicite lib\u00e8re la m\u00e9moire occup\u00e9e par l&rsquo;instance de la classe pour laquelle il est appel\u00e9, apr\u00e8s avoir appel\u00e9 automatiquement les destructeurs des instances contenues dans ses attributs, si applicable.<\/p>\n<p>Ces destructeurs implicites suffisent pour lib\u00e9rer toute la m\u00e9moire occup\u00e9e par les instances de classes sans ramification dans le tas, ce qui est le cas des classes <code>Point<\/code> et <code>Segment<\/code> donn\u00e9es en exemple.<\/p>\n<p>Mais lorsqu&rsquo;une classe a des attributs de type pointeur sur une instance de classe, les choses se compliquent. Il devient n\u00e9cessaire de d&rsquo;impl\u00e9menter un <strong>destructeur explicite<\/strong>.<\/p>\n<h4>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>D\u00e9finir un destructeur explicite<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Nous allons commencer par faire quelques exp\u00e9riences avec la classe <code>Segment<\/code> d\u00e9finie pr\u00e9c\u00e9demment, dans le but de voir quand le constructeur est appel\u00e9 automatiquement et quand il est n\u00e9cessaire de l&rsquo;appeler explicitement.<\/p>\n<p>Ajoutons un <strong>destructeur<\/strong> dans la classe <code>Segment<\/code>, dont la nouvelle d\u00e9claration est :<\/p>\n<pre><code class=\"language-c++\">class Segment\n{\n    private:\n    Point a;\n    Point b;\n    \n    public:\n    Segment(Point&amp; deb, Point&amp; fin);\n    Segment(double x1, double y1, double x2, double y2);\n    Point milieu();\n    void affiche();\n    \n    ~Segment();  \/\/ Destructeur\n};\n<\/code><\/pre>\n<p>Dans la d\u00e9finition du destructeur, on met un affichage dont le but est purement p\u00e9dagogique :<\/p>\n<pre><code class=\"language-c++\">Segment::~Segment()\n{\n    cout &lt;&lt; &quot;Destruction instance Segment &quot; &lt;&lt; this &lt;&lt; endl;\n}\n<\/code><\/pre>\n<p>Si on ex\u00e9cute la fonction suivante&#8230;<\/p>\n<pre><code class=\"language-c++\">void exemple1()\n{\n    Segment s(1.0,1.0,3.0,3.0);\n    s.affiche();\n}\n<\/code><\/pre>\n<p>&#8230;on obtient l&rsquo;affichage :<\/p>\n<pre><code>[(1,1),(3,3)]\nDestruction instance Segment 0x7ffe697eca10\n<\/code><\/pre>\n<p>Le destructeur a \u00e9t\u00e9 appel\u00e9 automatiquement \u00e0 l&rsquo;issue de l&rsquo;ex\u00e9cution de la fonction dans laquelle la variable <code>s<\/code> a \u00e9t\u00e9 d\u00e9clar\u00e9e. L&rsquo;adresse affich\u00e9e est celle o\u00f9 est implant\u00e9e (dans la pile) l&rsquo;instance de <code>Segment<\/code> concern\u00e9e. Elle change \u00e0 chaque ex\u00e9cution du programme.<\/p>\n<p>Si on ex\u00e9cute la fonction suivante&#8230;<\/p>\n<pre><code class=\"language-c++\">void exemple2()\n{\n    Segment s(1.0,1.0,3.0,3.0);\n    Segment* p = new Segment(1.5,0.5,2.0,2.0);\n    s.affiche();\n    p-&gt;affiche();\n}\n<\/code><\/pre>\n<p>&#8230;on obtient l&rsquo;affichage :<\/p>\n<pre><code>[(1,1),(3,3)]\n[(1.5,0.5),(2,2)]\nDestruction instance Segment 0x7ffe31cc9730\n<\/code><\/pre>\n<p>On constate que la deuxi\u00e8me instance de <code>Point<\/code>, qui a \u00e9t\u00e9 cr\u00e9\u00e9e dans le tas gr\u00e2ce \u00e0 l&rsquo;instruction <code>new<\/code>, n&rsquo;a pas \u00e9t\u00e9 d\u00e9truite.<\/p>\n<p><strong>Les instances cr\u00e9\u00e9es dans le tas ne sont pas automatiquement d\u00e9truites.<\/strong> La cr\u00e9ation de telles instances occasionne une &quot;dette m\u00e9moire&quot; qu&rsquo;il faudra rembourser en utilisant <code>delete<\/code> pour les d\u00e9truire.<\/p>\n<p>La destruction d&rsquo;une instance (par <code>delete<\/code>) ne se fait pas n\u00e9cessairement dans la fonction o\u00f9 cette instance a \u00e9t\u00e9 cr\u00e9\u00e9e (par <code>new<\/code>). Mais dans notre exemple simple, c&rsquo;est ce que nous allons faire :<\/p>\n<pre><code class=\"language-c++\">void exemple6()\n{\n    Segment s(1.0,1.0,3.0,3.0);\n    Segment* p = new Segment(1.5,0.5,2.0,2.0);\n    s.affiche();\n    p-&gt;affiche();\n    delete p;\n}\n<\/code><\/pre>\n<p>L&rsquo;affichage obtenu est :<\/p>\n<pre><code class=\"language-c++\">[(1,1),(3,3)]\n[(1.5,0.5),(2,2)]\nDestruction instance Segment 0x5573559f92c0\nDestruction instance Segment 0x7ffe11f740b0\n<\/code><\/pre>\n<p>Les deux instances ont \u00e9t\u00e9 d\u00e9truites par appel du destructeur de la classe <code>Segment<\/code>. Le destructeur de l&rsquo;instance situ\u00e9e dans la pile a \u00e9t\u00e9 appel\u00e9 automatiquement. Celui de l&rsquo;instance situ\u00e9es dans le tas a \u00e9t\u00e9 appel\u00e9 explicitement.<\/p>\n<p>Mais nous n&rsquo;avons rien mis dans ce destructeur, except\u00e9 un affichage. En effet, le m\u00e9canisme de destruction est ajout\u00e9 de mani\u00e8re implicite au destructeur et aucun code sp\u00e9cifique n&rsquo;est n\u00e9cessaire&#8230; tant que la classe concern\u00e9e n&rsquo;a pas de ramification dans le tas.<\/p>\n<hr>\n<p>Dans un but purement p\u00e9dagogique, nous allons d\u00e9clarer et d\u00e9finir une nouvelle variante de la classe <code>Segment<\/code> avec ramification dans le tas :<\/p>\n<pre><code class=\"language-c++\">class Seg\n{\n    private:\n    Point* a;\n    Point* b;\n    \n    public:\n    Seg(Point&amp; deb, Point&amp; fin);\n    Seg(double x1, double y1, double x2, double y2);\n    \n    Point milieu();\n    void affiche();\n    \n    ~Seg();\n};\n<\/code><\/pre>\n<p>Cette classe a les m\u00eames m\u00e9thodes que la classe <code>Segment<\/code> d\u00e9finie pr\u00e9c\u00e9demment, mais ses attributs sont de type pointeur sur <code>Point<\/code> et cela change beaucoup de choses. Pour s&rsquo;en convaincre, on peut observer la repr\u00e9sentation en m\u00e9moire d&rsquo;une instance de <code>Segment<\/code>, non ramifi\u00e9e&#8230;<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/l2g2.png\" alt=\"l2g2\"><\/p>\n<p>&#8230;et d&rsquo;une instance de <code>Seg<\/code> :<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/l2g3.png\" alt=\"l2g3\"><\/p>\n<p>Une instance de <code>Segment<\/code> est monolithique, i.e. constitu\u00e9e d&rsquo;un seul bloc de m\u00e9moire. Une instance de <code>Seg<\/code> est constitu\u00e9e de trois blocs de m\u00e9moire : un socle, qui peut \u00eatre situ\u00e9 dans la pile ou dans le tas, et deux blocs, n\u00e9cessairement situ\u00e9s dans le tas, qui seront cr\u00e9\u00e9 \u00e0 l&rsquo;aide de <code>new<\/code> par les constructeurs de <code>Seg<\/code>. Ces deux blocs devront \u00eatre explicitement d\u00e9truits par des appels \u00e0 <code>delete<\/code> dans le destructeur de <code>Seg<\/code>. De fait il devient n\u00e9cessaire de d\u00e9finir un destructeur explicite dans la classe <code>Seg<\/code>.<\/p>\n<p>Voici les d\u00e9finitions des constructeurs de la classe <code>Seg<\/code> :<\/p>\n<pre><code class=\"language-c++\">Seg::Seg(Point&amp; deb, Point&amp; fin)\n{\n    this-&gt;a = new Point(deb);\n    this-&gt;b = new Point(fin);\n}\n\nSeg::Seg(double x1, double y1, double x2, double y2) \n{\n    this-&gt;a = new Point(x1,y1);\n    this-&gt;b = new Point(x2,y2);\n}\n<\/code><\/pre>\n<p>Dans la premi\u00e8re version, le constructeur en copie de la classe <code>Point<\/code> (qui est d\u00e9fini implicitement car <code>Point<\/code> est une classe sans ramification dans le tas) est appel\u00e9. Dans la deuxi\u00e8me version, le constructeur \u00e0 deux param\u00e8tres de la classe <code>Point<\/code> est appel\u00e9. Dans les deux cas, les instances de <code>Point<\/code> sont cr\u00e9\u00e9e dans le tas par l&rsquo;op\u00e9rateur <code>new<\/code>.<\/p>\n<p>L&rsquo;utilisation de <code>new<\/code> dans le constructeur, qui correspond \u00e0 la cr\u00e9ation d&rsquo;une ramification dans le tas, implique la d\u00e9finition d&rsquo;un destructeur qui d\u00e9truira cette ramification.<\/p>\n<h5>Exercice de d\u00e9couverte G.dec.x10<\/h5>\n<p>Donnez la d\u00e9finition de la m\u00e9thode <code>Seg::milieu<\/code>. Pour m\u00e9moire, la d\u00e9finition de <code>Segment::milieu<\/code> \u00e9tait :<\/p>\n<pre><code class=\"language-c++\">Point Segment::milieu()\n{\n    return a.milieu(b);\n}\n<\/code><\/pre>\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++\">Point Seg::milieu()\n{\n    return a-&gt;milieu(*b);\n}\n<\/code><\/pre>\n<p>Le point <code>.<\/code> a \u00e9t\u00e9 remplac\u00e9 par la fl\u00e8che <code>-&gt;<\/code> pour l&rsquo;appel de la m\u00e9thode <code>Point::milieu<\/code> parce que <code>a<\/code> d\u00e9signe une <strong>adresse<\/strong> d&rsquo;instance de <code>Point<\/code>.<\/p>\n<p>Le param\u00e8tre de la m\u00e9thode <code>Point::milieu<\/code> est de type <code>Point&amp;<\/code> et s&rsquo;utilise comme un param\u00e8tre de type <code>Point<\/code>. Or l&rsquo;attribut <code>b<\/code> n&rsquo;est pas de type <code>Point<\/code>, mais de type <code>Point*<\/code>. Lors de l&rsquo;appel de la m\u00e9thode, on doit donc utiliser l&rsquo;op\u00e9rateur de &quot;d\u00e9pointage&quot; <code>*<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>La m\u00e9thode d&rsquo;affichage de <code>Seg<\/code> est d\u00e9finie comme suit :<\/p>\n<pre><code class=\"language-c++\">void Seg::affiche()\n{\n    cout &lt;&lt; &quot;[&quot;;\n    a-&gt;affiche();\n    cout &lt;&lt; &quot;,&quot;;\n    b-&gt;affiche();\n    cout &lt;&lt; &quot;]&quot; &lt;&lt; endl;\n}\n<\/code><\/pre>\n<hr>\n<p>Voici la d\u00e9finition du <strong>destructeur<\/strong> de la classe <code>Seg<\/code> :<\/p>\n<pre><code class=\"language-c++\">Seg::~Seg()\n{\n    delete this-&gt;a;\n    delete this-&gt;b;\n}\n<\/code><\/pre>\n<p>Il contient le code permettant d\u00e9 d\u00e9truire les instances de <code>Point<\/code> point\u00e9es par les deux attributs <code>a<\/code> et <code>b<\/code>.<\/p>\n<hr>\n<p>La classe <code>Seg<\/code> s&rsquo;utilise exactement comme la classe <code>Segment<\/code>, mais en l&rsquo;\u00e9tat, son utilisation peut conduire \u00e0 des effets de bord dans certaines situations que nous ne d\u00e9velopperons pas dans ici, mais qui seront abord\u00e9es dans la partie H. Cette classe <code>Seg<\/code> pr\u00e9sente donc des inconv\u00e9nients et pas vraiment d&rsquo;avantages par rapport \u00e0 la classe <code>Segment<\/code>.<\/p>\n<h5>Exercice de d\u00e9couverte G.dec.x11<\/h5>\n<p>L&rsquo;ex\u00e9cution des lignes de code suivantes&#8230;<\/p>\n<pre><code class=\"language-c++\">    cout &lt;&lt; sizeof(Point) &lt;&lt; endl;\n    cout &lt;&lt; sizeof(Point*) &lt;&lt; endl;\n<\/code><\/pre>\n<p>&#8230;produisent l&rsquo;affichage :<\/p>\n<pre><code>16\n8\n<\/code><\/pre>\n<p>Tentez de d\u00e9terminer les affichage produits par les deux lignes de code suivantes :<\/p>\n<pre><code class=\"language-c++\">    cout &lt;&lt; sizeof(Segment) &lt;&lt; endl;\n    cout &lt;&lt; sizeof(Seg) &lt;&lt; endl;\n<\/code><\/pre>\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>32\n16\n<\/code><\/pre>\n<p>Une instance de <code>Segment<\/code> contient deux instances de Point occupant chacune 16 octets en m\u00e9moire, alors qu&rsquo;une instance de <code>Seg<\/code> contient deux pointeurs occupant chacun 8 octets en m\u00e9moire.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3>G.dec7 :  \u00c0  propos des tableaux au format C<\/h3>\n<p>Cette partie ne sera pas incluse dans les \u00e9valuations mais ouvre la porte \u00e0 une programmation de plus bas niveau en C++, c&rsquo;est \u00e0 dire la r\u00e9alisation de classes et programmes n&rsquo;utilisant pas les classes standards telles que <code>string<\/code> et <code>vector<\/code>.<\/p>\n<h4>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Parties C, E, et sections G.dec1 \u00e0 G.dec6<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Cr\u00e9er et utiliser des tableaux de bas niveau en C++<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Les tableaux au format C sont de simples blocs de m\u00e9moire, d\u00e9sign\u00e9s par des pointeurs. L&rsquo;int\u00e9r\u00eat d&rsquo;une repr\u00e9sentation aussi rudimentaire est d&rsquo;optimiser l&rsquo;efficacit\u00e9 de leur utilisation en termes d&rsquo;espace m\u00e9moire et de temps CPU.<\/p>\n<p>Il est possible d&rsquo;utiliser une telle repr\u00e9sentation en C++.<\/p>\n<h4>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>D\u00e9clarations de tableaux de bas niveau<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Les tableaux situ\u00e9s dans la pile ou les tableaux de tailles fixe utilis\u00e9s comme attributs d&rsquo;une classe se d\u00e9clarent exactement comme en langage C.<\/p>\n<p>On peut, par exemple, cr\u00e9er un tableau d&rsquo;instances de <code>Point<\/code> comme ceci :<\/p>\n<pre><code class=\"language-c++\">Point tab[3];\n<\/code><\/pre>\n<p>Contrairement \u00e0 ce qui ce passe en langage C, en C++ tout tableau est initialis\u00e9. Dans le cas ou aucune initialisation explicite n&rsquo;est r\u00e9alis\u00e9e (comme dans l&rsquo;exemple ci-dessus), les objets contenus dans le tableau sont initialis\u00e9s avec le constructeur par d\u00e9faut de la classe concern\u00e9e.<\/p>\n<hr>\n<p>Les tableaux dynamiques doivent \u00eatre cr\u00e9\u00e9s avec l&rsquo;op\u00e9rateur <code>new<\/code>. Voici un exemple :<\/p>\n<pre><code class=\"language-c++\">Point* t = new Point[3];\n<\/code><\/pre>\n<p>Ils sont initialis\u00e9s avec le constructeur par d\u00e9faut de la classe concern\u00e9e. Il occasionnent une dette m\u00e9moire qui doit \u00eatre rembours\u00e9e ult\u00e9rieurement en utilisant l&rsquo;op\u00e9rateur <code>delete[]<\/code> (avec des crochets vides).<\/p>\n<pre><code class=\"language-c++\">delete[] t;\n<\/code><\/pre>\n<h2>Activit\u00e9 d&rsquo;entra\u00eenement G.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>It\u00e9ration G.ent1<\/h3>\n<h4>Exercice d&rsquo;entrainement G.ent1.1<\/h4>\n<p>R\u00e9alisez une classe <code>Date<\/code> repr\u00e9sentant une date constitu\u00e9e d&rsquo;un jour, d&rsquo;un mois et d&rsquo;une ann\u00e9. Cette classe doit disposer<\/p>\n<ul>\n<li>d&rsquo;un constructeur par d\u00e9faut permettant de cr\u00e9er une instance repr\u00e9sentant le premier janvier 1900,<\/li>\n<li>d&rsquo;un constructeur acceptant en param\u00e8tre le jour, le mois et l&rsquo;ann\u00e9e de l&rsquo;instance \u00e0 cr\u00e9er,<\/li>\n<li>de m\u00e9thodes d&rsquo;acc\u00e8s permettant de lire et modifier le jour, le mois et l&rsquo;ann\u00e9e,<\/li>\n<li>d&rsquo;une m\u00e9thode <code>affiche<\/code> permettant d&rsquo;afficher l&rsquo;instance courantre (l&rsquo;instance avec laquelle la m\u00e9thode est appel\u00e9e) dans le format <code>1\/1\/1900<\/code>.<\/li>\n<\/ul>\n<p>Donnez d&rsquo;abord la d\u00e9claration de la classe.<\/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++\">class Date\n{\n  private:\n  int jour;\n  int mois;\n  int annee;\n  \n  public:\n  Date();\n  Date(int j, int m, int a);\n  \n  int getJour(); \n  int getMois(); \n  int getAnnee();\n  void setJour(int j);\n  void setMois(int m);\n  void setAnnee(int a);\n  void affiche();\n};\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>D\u00e9finissez maintenant les deux constructeurs.<\/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>Voici les versions avec liste d&rsquo;initialisation :<\/p>\n<pre><code class=\"language-c++\">Date::Date() : \njour(1), mois(1), annee(1900)\n{\n}\n\nDate::Date(int j, int m, int a) : \njour(j), mois(m), annee(a)\n{\n}\n<\/code><\/pre>\n<p>Et les versions avec initialisation dans le corps :<\/p>\n<pre><code class=\"language-c++\">Date::Date()\n{\n    jour = 1; mois = 1; annee = 1;\n}\n\nDate::Date(int j, int m, int a)\n{\n    jour = j; mois = m; annee = a;\n}\n<\/code><\/pre>\n<p>Je ne pense pas qu&rsquo;il y ait une diff\u00e9rence d&rsquo;efficacit\u00e9 entre les deux versions car les attributs ne contiennent pas des instances de classes mais de simples donn\u00e9es de type <code>int<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>D\u00e9finissez maintenant les m\u00e9thode d&rsquo;acc\u00e8s.<\/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 Date::getJour() {return jour;}\nint Date::getMois() {return mois;}\nint Date::getAnnee() {return annee;}\n\nvoid Date::setJour(int j){jour = j;}\nvoid Date::setMois(int m){mois = m;}\nvoid Date::setAnnee(int a){annee = a;}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Maintenant la m\u00e9thode d&rsquo;affichage.<\/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 Date::affiche()\n{\n    cout &lt;&lt; getJour() &lt;&lt; &quot;\/&quot; &lt;&lt; getMois() &lt;&lt; &quot;\/&quot; &lt;&lt; getAnnee();\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>D\u00e9finissez une fonction <code>test_Date<\/code> qui r\u00e9alise les actions suivantes :<\/p>\n<ul>\n<li>Cr\u00e9ation d&rsquo;une instance de <code>Date<\/code> dans la pile avec le constucteur par d\u00e9faut. Cette instance doit \u00eatre plac\u00e9e dans une variable <code>d1<\/code>.<\/li>\n<li>Cr\u00e9ation d&rsquo;une instance de <code>Date<\/code> dans le tas, initialis\u00e9e avec le constructeur \u00e0 3 param\u00e8tres pour repr\u00e9senter le 28 f\u00e9vrier 2022. L&rsquo;adresse de cette instance doit \u00eatre plac\u00e9e dans une variabble <code>d2<\/code>.<\/li>\n<li>Modification de l&rsquo;ann\u00e9e de la date d\u00e9sign\u00e9e par <code>d1<\/code> pour lui donner la vaelur 2022.<\/li>\n<li>Affichage des dates d\u00e9sign\u00e9es par <code>d1<\/code> et <code>d2<\/code>.<\/li>\n<\/ul>\n<p>L&rsquo;ex\u00e9cution de cette fonction ne devra provoquer aucune fuite m\u00e9moire.<\/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 test_Date()\n{\n    Date d1;\n    Date* d2 = new Date(28, 2, 2022);\n    d1.setAnnee(2022);\n    d1.affiche();\n    cout &lt;&lt; endl;\n    d2-&gt;affiche();\n    delete d2;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4>Exercice d&rsquo;entrainement G.ent1.2<\/h4>\n<p>Ajoutez \u00e0 la classe <code>Date<\/code> une fonction&#8230;<\/p>\n<pre><code class=\"language-c++\">int Date::compare(Date &amp; autre);\n<\/code><\/pre>\n<p>&#8230;permettant de comparer la date courante avec une autre date et qui retourne :<\/p>\n<ul>\n<li>0 si les deux date sont identiques,<\/li>\n<li>un entier n\u00e9gatif si la date courante est ant\u00e9rieure \u00e0 l&rsquo;autre date,<\/li>\n<li>sinon une valeur positive.<\/li>\n<\/ul>\n<p>Essayez de produire un code aussi simple que possible.<\/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>Voici une version utilisant les m\u00e9thodes d&rsquo;acc\u00e8s.<\/p>\n<pre><code class=\"language-c++\">int Date::compare(Date&amp; autre)\n{\n    if(this-&gt;getAnnee() != autre.getAnnee()) \n    {\n        return this-&gt;getAnnee() - autre.getAnnee();\n    }\n    else if(this-&gt;getMois() != autre.getMois()) \n    {\n        return this-&gt;getMois() - autre.getMois();\n    }\n    else\n    {\n        return this-&gt;getJour() - autre.getJour();\n    }\n}\n<\/code><\/pre>\n<p>Un version avec acc\u00e8s direct au attributs, c&rsquo;est \u00e0 dire dans laquelle on remplacerait <code>getAnnee<\/code> par <code>annee<\/code>, <code>getMois<\/code> par <code>mois<\/code>, etc., compile et fonctionne parfaitement. Cependant elle a un incov\u00e9nient en terme de maintenabilit\u00e9 du code. En effet, si on change la repr\u00e9sentation d&rsquo;une date ou m\u00eame le nom des attributs, mais en adaptant  en cons\u00e9quence les m\u00e9thodes d&rsquo;acc\u00e8s, toutes les autres m\u00e9thodes utilisant ces m\u00e9thodes d&rsquo;acc\u00e8s continueront de fonctionner, alors qu&rsquo;avec un acc\u00e8s direct aux attributs, il faudra modifier toutes les m\u00e9thodes de la classes pour retrouver un fonctionnement coh\u00e9rent.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>On change la repr\u00e9sentation d&rsquo;une date dans la classe <code>Date<\/code>. Au lieu de la repr\u00e9senter par trois entiers, on la repr\u00e9sente par un seul entier $j + 100 m + 10000 a$, avec $a$ l&rsquo;ann\u00e9e, $m$ le mois et $j$ le jour. Par exemple le 28 f\u00e9vrier 2022 sera repr\u00e9sent\u00e9 par l&rsquo;entier 20220000 + 200 + 28 = 20220228.<\/p>\n<p>La nouvelle classe a donc un unique attribut priv\u00e9 que nous nommerons <code>code<\/code>.<\/p>\n<p>On ajoute une nouvelle m\u00e9thode d&rsquo;acc\u00e8s :<\/p>\n<pre><code class=\"language-c++\">void Date::setAll(int j, int m, int a)\n{\n    code = 10000*a + 100*m + j;\n}\n<\/code><\/pre>\n<p>Donnez les nouvelles m\u00e9thodes d&rsquo;acc\u00e8s <code>getAnnee<\/code>, <code>getMois<\/code>, <code>getJour<\/code>, <code>setAnnee<\/code>, <code>setMois<\/code>, <code>setJour<\/code> qui permettent aux m\u00e9thodes qui acc\u00e9daient aux attributs uniquement avec les m\u00e9thodes d&rsquo;acc\u00e8s de continuer \u00e0 fonctionner sans aucune modification. Vous pouvez utiliser la m\u00e9thode <code>setAll<\/code> pour simplifier et clarifier votre 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++\">int Date::getJour() {return code%100;}\n\nint Date::getMois() {return (code\/100)%100;}\n\nint Date::getAnnee() {return code\/10000;}\n\nvoid Date::setJour(int j)\n{\n    setAll(j, getMois(), getAnnee());\n}\n\nvoid Date::setMois(int m)\n{\n    setAll(getJour(), m, getAnnee());\n}\n\nvoid Date::setAnnee(int a)\n{\n    setAll(getJour(), getMois(), a);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Mais puisque nous avons chang\u00e9 les attributs, il faut aussi changer les constructeurs. D\u00e9finissez le nouveau constructeur par d\u00e9faut et le nouveau constructeur \u00e0 trois param\u00e8tres de mani\u00e8re aussi <s>classe<\/s> \u00e9l\u00e9gante que possible.<\/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++\">Date::Date()\n{\n    setAll(1, 1, 1900);\n}\n\nDate::Date(int j, int m, int a)\n{\n    setAll(j, m, a);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>\u00c0 pr\u00e9sent (sauf si j&rsquo;ai laiss\u00e9 une coquille dans les solutions propos\u00e9es) les m\u00e9thodes <code>affiche<\/code> et <code>compare<\/code> fonctionnent comme avant sans aucun changement de leur code.<\/p>\n<p>Mais il est possible de simplifier consid\u00e9rablement la m\u00e9thode <code>compare<\/code>. Proposez une solution.<\/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>Le codage utilis\u00e9 pour repr\u00e9senter les dates a une propri\u00e9t\u00e9 tr\u00e8s int\u00e9ressante : une date est ant\u00e9rieure \u00e0 une autre si et seulement si son code est inf\u00e9rieur \u00e0 celui de l&rsquo;autre date. Bien sur, deux dates sont identiques si et seulement si leur codes sont \u00e9gaux.<\/p>\n<pre><code class=\"language-c++\">int Date::getCode() {return code;}\n\nint Date::compare(Date&amp; autre)\n{\n    return this-&gt;getCode() - autre.getCode();\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4>Exercice d&rsquo;entrainement G.ent1.3<\/h4>\n<p>On d\u00e9finit une classe <code>Moment<\/code> repr\u00e9sentant une heure de la journ\u00e9e sp\u00e9cifi\u00e9e avec une r\u00e9solution d&rsquo;une minute.<\/p>\n<pre><code class=\"language-c++\">class Moment\n{\n  private:\n  int heure;\n  int min;\n    \n  public:\n  Moment();\n  Moment(int h, int m);\n  \n  int getHeure(); \n  int getMin(); \n  void setHeure(int h);\n  void setMin(int m);\n  void affiche();\n};\n<\/code><\/pre>\n<pre><code class=\"language-c++\">Moment::Moment() :\nheure(0), min(0)\n{\n}\n\nMoment::Moment(int h, int m) :\nheure(h), min(m)\n{\n}\n\nint Moment::getHeure() {return heure;}\nint Moment::getMin() {return min;}\n\nvoid Moment::setHeure(int h)\n{\n    heure = h;\n}\n\nvoid Moment::setMin(int m)\n{\n    min = m;\n}\n\nvoid Moment::affiche()\n{\n    cout &lt;&lt; getHeure() &lt;&lt; &quot;:&quot; &lt;&lt; getMin();\n}\n<\/code><\/pre>\n<hr>\n<p>Vous devez d\u00e9finir une classe <code>Creneau<\/code> qui repr\u00e9sente un cr\u00e9neau situ\u00e9 entre deux moments d&rsquo;une journ\u00e9e. Par exemple, un cr\u00e9neau peut \u00eatre de 16h30 \u00e0 17h00 le 6 juillet 2021.<\/p>\n<p>Voici la d\u00e9claration de la classe :<\/p>\n<pre><code class=\"language-c++\">class Creneau\n{\n    private:\n    Date date;\n    Moment deb;\n    Moment fin;\n    \n    public:\n    Creneau();\n    Creneau(Date d, Moment deb, Moment f);\n    \n    Date getDate();\n    Moment getDeb();\n    Moment getFin();\n    void setDate(Date&amp; d);\n    void setDeb(Moment&amp; m);\n    void setFin(Moment&amp; m);\n    \n    void affiche();\n    int duree();\n};\n<\/code><\/pre>\n<p>Vous devez donner les d\u00e9finitions des constructeurs.<\/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++\">Creneau::Creneau()\n{\n}\n\nCreneau::Creneau(Date date, Moment d, Moment f) :\ndate(date), deb(d), fin(f)\n{\n}\n<\/code><\/pre>\n<p>Le premier constructeur peut para\u00eetre bizarre parce qu&rsquo;il n&rsquo;a pas de code. En fait, s&rsquo;il n&rsquo;y a pas d&rsquo;initialisation explicite des attibuts de la classe, alors il sont automatiquement initialis\u00e9s avec les constructeurs par d\u00e9faut des classes concern\u00e9es. L&rsquo;attribut <code>date<\/code> est initialis\u00e9 avec le constructeur par d\u00e9faut de la classe <code>Date<\/code>. L&rsquo;attribut <code>deb<\/code> est initialis\u00e9 avec le constructeur par d\u00e9faut de la classe <code>Moment<\/code>, etc.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Donnez les d\u00e9finitions des m\u00e9thodes d&rsquo;acc\u00e8s.<\/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++\">Date Creneau::getDate() {return date;}\nMoment Creneau::getDeb() {return deb;}\nMoment Creneau::getFin() {return fin;}\n\nvoid Creneau::setDate(Date&amp; d)\n{\n    date = d;\n}\nvoid Creneau::setDeb(Moment&amp; m)\n{\n    deb = m;\n}\nvoid Creneau::setFin(Moment&amp; m)\n{\n    fin = m;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Donnez la d\u00e9finition de la m\u00e9thode <code>affiche<\/code> qui doit produire un affichage ressemblant \u00e0 ceci :<\/p>\n<pre><code>28\/2\/2022 [14:15..15:30] \n<\/code><\/pre>\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 Creneau::affiche()\n{\n    date.affiche();\n    cout &lt;&lt; &quot; [&quot;;\n    deb.affiche();\n    cout &lt;&lt; &quot;..&quot;;\n    fin.affiche();\n    cout &lt;&lt; &quot;] &quot;;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Puis la d\u00e9finition de la m\u00e9thode <code>duree<\/code> qui retourne la dur\u00e9e d&rsquo;un cr\u00e9neau exprim\u00e9e en minutes.<\/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 Creneau::duree()\n{\n    int t1 = deb.getHeure()*60 + deb.getMin();\n    int t2 = fin.getHeure()*60 + fin.getMin();\n    return t2-t1;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Vous devez d\u00e9finir une m\u00e9thode de test qui r\u00e9alise les actions suivantes :<\/p>\n<ol>\n<li>Cr\u00e9ation dans la pile d&rsquo;une instance de <code>Creneau<\/code> correspondant au 28 f\u00e9vrier 2022 de 14h15 \u00e0 15h30.<\/li>\n<li>Affichage de ce cr\u00e9neau.<\/li>\n<li>Affichage de la dur\u00e9e du cr\u00e9neau.<\/li>\n<li>Cr\u00e9ation dans le tas d&rsquo;une copie de l&rsquo;instance de <code>Creneau<\/code> cr\u00e9\u00e9e \u00e0 l&rsquo;\u00e9tape 1. Vous devez utiliser le constructeur en copie de la classe <code>Creneau<\/code>. Pour m\u00e9moire, toute classe dispose d&rsquo;une constructeur en copie implicite qui fonctionne bien dans le cas des classe monolithiques.<\/li>\n<li>Affichage de l&rsquo;instance de <code>Creneau<\/code> situ\u00e9e dans le tas cr\u00e9\u00e9e \u00e0 l&rsquo;\u00e9tape 4.<\/li>\n<li>Lib\u00e9ration de la 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 test_Creneau()\n{\n    Creneau p1(Date(28,2,2022), Moment(14,15), Moment(15,30));\n    p1.affiche();\n    cout &lt;&lt; endl &lt;&lt; p1.duree() &lt;&lt; endl;\n    Creneau* p2 = new Creneau(p1);\n    p2-&gt;affiche();\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>On ex\u00e9cute le code suivant :<\/p>\n<pre><code class=\"language-c++\">    Creneau cr;\n    cr.getDate().setAnnee(2023);\n    cr.affiche();\n<\/code><\/pre>\n<p>L&rsquo;affichage obtenu est :<\/p>\n<pre><code>1\/1\/1900 [0:0..0:0] \n<\/code><\/pre>\n<p>Pourtant, <code>cr.getDate()<\/code> retourne la date du cr\u00e9neau et <code>setAnnee<\/code> a pour r\u00f4le d&rsquo;en modifier l&rsquo;ann\u00e9e. Pourquoi l&rsquo;ann\u00e9e de la date du cr\u00e9neau d\u00e9sign\u00e9 par <code>cr<\/code> n&rsquo;a-t-elle pas \u00e9t\u00e9 modif\u00e9e ?<\/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>La m\u00e9thode <code>getDate<\/code> retourne une <strong>copie<\/strong> de l&rsquo;instance de <code>Date<\/code> contenue dans l&rsquo;attribut <code>date<\/code>. Modifier l&rsquo;ann\u00e9e de cette copie ne change pas la date d\u00e9sign\u00e9e par l&rsquo;attribut <code>Date<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Peut-on modifier la m\u00e9thode <code>getDate<\/code> pour que les trois lignes de code pr\u00e9sent\u00e9es plus haut aient pour effet l&rsquo;affichage ci dessous ?<\/p>\n<pre><code>1\/1\/2023 [0:0..0:0] \n<\/code><\/pre>\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>Oui, voici la nouvelle version :<\/p>\n<pre><code class=\"language-c++\">Date&amp; Creneau::getDate() {return date;}\n<\/code><\/pre>\n<p>La variante retourne une <strong>r\u00e9f\u00e9rence<\/strong> de l&rsquo;attribut <code>date<\/code>, \u00e0 partir de laquelle il est possible de modifier l&rsquo;attribut.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h4>Exercice d&rsquo;entrainement G.ent1.4<\/h4>\n<p>Dans cet exercice, nous r\u00e9utiliserons la classe <code>Creneau<\/code> de l&rsquo;exercice pr\u00e9c\u00e9dent dans une version o\u00f9 les m\u00e9thodes d&rsquo;acc\u00e8s en lecture retournent les r\u00e9f\u00e9rences des attributs lus.<\/p>\n<pre><code class=\"language-c++\">class Creneau\n{\n    private:\n    Date date;\n    Moment deb;\n    Moment fin;\n    \n    public:\n    Creneau();\n    Creneau(Date d, Moment deb, Moment f);\n    \n    Date&amp; getDate();\n    Moment&amp; getDeb();\n    Moment&amp; getFin();\n    void setDate(Date&amp; d);\n    void setDeb(Moment&amp; m);\n    void setFin(Moment&amp; m);\n    \n    void affiche();\n    int duree();\n};\n<\/code><\/pre>\n<p>Nous introduisons une nouvelle classe <code>Planning<\/code> permettant de repr\u00e9senter une liste de cr\u00e9neaux.<\/p>\n<pre><code class=\"language-c++\">class Planning\n{\n  private:\n  vector&lt;Creneau&gt; data;\n  \n  public:\n  void add(Creneau&amp; cr);\n  void add(int j, int m, int a, int hd, int md, int dur);\n  void affiche();\n  int size();\n  Creneau&amp; getCreneau(int i);\n};\n<\/code><\/pre>\n<p>Cette classe a un constructeur par d\u00e9faut implicite qui initialise l&rsquo;attribut <code>data<\/code> avec le constructeur par d\u00e9faut de la classe <code>vector<\/code>, qui cr\u00e9e un vecteur vide. Il n&rsquo;est donc pas n\u00e9cessaire de d\u00e9finir un constructeur par d\u00e9faut explicite.<\/p>\n<hr>\n<p>D\u00e9finissez la m\u00e9thode <code>add<\/code> \u00e0 un param\u00e8tre qui ajoute un nouveau cr\u00e9neau dans le vecteur <code>data<\/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++\">void Planning::add(Creneau&amp; cr)\n{\n    data.push_back(cr);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>D\u00e9finissez la m\u00e9thode <code>add<\/code> \u00e0 6 param\u00e8tres qui ajoute un nouveau cr\u00e9neau d\u00e9finit par le jour <code>j<\/code>, le mois <code>m<\/code>, l&rsquo;ann\u00e9e <code>a<\/code>, le moment du d\u00e9but sp\u00e9cifi\u00e9 par <code>hd<\/code> (heure) et <code>md<\/code> (minutes), et la dur\u00e9e <code>dur<\/code> exprim\u00e9e en minutes. Il faudra d\u00e9terminer le moment de fin en fonction de <code>hd<\/code>, <code>md<\/code> et <code>dur<\/code>.<\/p>\n<p>L&rsquo;indice concerne la mani\u00e8re de calculer le moment de fin.<\/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>Pour calculer l&rsquo;heure:minute de fin \u00e0 partir de l&rsquo;heure:minute de d\u00e9but, on peut convertir en minutes le moment de d\u00e9but, puis ajouter la dur\u00e9e en minutes, et enfin convertir le r\u00e9sultat en heure:minute.<\/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++\">void Planning::add(int j, int m, int a, int hd, int md, int dur)\n{\n    int fin = hd*60 + md + dur;\n    int hf = fin\/60;\n    int mf = fin%60;\n    Creneau cr(Date(j,m,a), Moment(hd,md), Moment(hf,mf));\n    data.push_back(cr);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>D\u00e9finissez les deux m\u00e9thodes <code>size<\/code> et <code>getCreneau<\/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++\">int Planning::size() {return data.size();}\n\n\nCreneau&amp; Planning::getCreneau(int i)\n{\n    return data[i];\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>D\u00e9finissez la m\u00e9thode <code>affiche<\/code>. Elle doit afficher tous les cr\u00e9neaux du planning.<\/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 Planning::affiche()\n{\n    int n = size();\n    for(int i=0; i&lt;n; i++)\n    {\n        getCreneau(i).affiche();\n        cout &lt;&lt; endl;\n    }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Donnez les lignes de code permettant de r\u00e9aliser les actions suivantes :<\/p>\n<ol>\n<li>D\u00e9claration d&rsquo;une variable <code>cr<\/code> de type <code>Creneau<\/code> initialis\u00e9e avec cr\u00e9neau <code>28\/2\/2022 [14:15..15:30]<\/code>.<\/li>\n<li>D\u00e9claration d&rsquo;une variable <code>p<\/code> de type <code>Planning<\/code> initialis\u00e9e avec le constructeur par d\u00e9faut de la classe <code>Planning<\/code>.<\/li>\n<li>Ajout du cr\u00e9neau d\u00e9sign\u00e9 par <code>cr<\/code>, deux fois de suite, au planning d\u00e9sign\u00e9 par <code>p<\/code>.<\/li>\n<li>Modification du deuxi\u00e8me cr\u00e9neau du planning : le mois doit prendre la valeur 3 et l&rsquo;heure de fin doit prendre la valeur 16.<\/li>\n<li>Ajout au planning, en utilisant la m\u00e9thode <code>add<\/code> \u00e0 6 param\u00e8tres, du cr\u00e9neau de 60 minutes commen\u00e7ant le 1\/3\/2022 \u00e0 10h15.<\/li>\n<li>Affichage du planning.<\/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++\">    Creneau cr(Date(28,2,2022), Moment(14,15), Moment(15,30));\n    Planning p;\n    p.add(cr);\n    p.add(cr);\n    cout &lt;&lt; endl;\n    p.getCreneau(1).getDate().setMois(3);\n    p.getCreneau(1).getFin().setHeure(16);\n    p.add(1,3,2022,10,15,60);\n    p.affiche();\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3>It\u00e9ration G.ent2<\/h3>\n<h4>Exercice d&rsquo;entrainement G.ent2.1<\/h4>\n<p>En logique propositionnelle, on appelle <strong>litt\u00e9ral<\/strong> l&rsquo;association d&rsquo;un symbole (nom, identificateur&#8230;) et d&rsquo;un signe. Voici des exemples de litt\u00e9raux en notation math\u00e9matique :<\/p>\n<ul>\n<li>Litt\u00e9raux positifs : $\\text{a}, \\text{alpha}, \\text{rouge}$.<\/li>\n<li>Litt\u00e9raux n\u00e9gatifs : $\\neg \\text{a}, \\neg \\text{beta}, \\neg \\text{bleu}$<\/li>\n<\/ul>\n<p>Pour faciliter les affichages \u00e0 l&rsquo;\u00e9cran, nous utiliserons les notations suivantes :<\/p>\n<ul>\n<li>Litt\u00e9raux positifs : <code>+a<\/code>, <code>+alpha<\/code>, <code>+rouge<\/code>.<\/li>\n<li>Litt\u00e9raux n\u00e9gatifs : <code>-a<\/code>, <code>-alpha<\/code>, <code>-vert<\/code>.<\/li>\n<\/ul>\n<p>Voici la d\u00e9claration de la classe <code>Litteral<\/code> permettant de repr\u00e9senter des litt\u00e9raux.<\/p>\n<pre><code class=\"language-c++\">class Litteral\n{\nprivate:\n    string id;\n    bool signe;\n    \npublic:\n    Litteral(int signe, const string&amp; id);\n    void affiche();\n    bool getSigne();\n    string getId();\n    bool egal(Litteral&amp; autre);\n};\n<\/code><\/pre>\n<p>Le type <code>bool<\/code> permet de repr\u00e9senter les valeur Bool\u00e9ennes avec la m\u00eame convention qu&rsquo;en langage C. On pourrait utiliser <code>int<\/code> \u00e0 la place. Les valeurs <code>true<\/code> et <code>false<\/code> sont \u00e9galement utilisables en C++. Elles repr\u00e9sentent les entiers 1 et 0.<\/p>\n<hr>\n<p>Donnez la d\u00e9finition du constructeur \u00e0 deux param\u00e8tres. Le type <code>const string&amp;<\/code> indique que le deuxi\u00e8me param\u00e8tre est la r\u00e9f\u00e9rence d&rsquo;une instance de <code>string<\/code> et que cette instance ne sera pas modifi\u00e9e.<\/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++\">Litteral::Litteral(int signe, const string&amp; id) :\nid(id), signe(signe)\n{\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Donnez les d\u00e9finitions des m\u00e9thodes <code>affiche<\/code>, <code>getSigne<\/code> et <code>getId<\/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++\">void Litteral::affiche()\n{\n    if(signe) cout &lt;&lt; &quot;+&quot; &lt;&lt; id &lt;&lt; &quot; &quot;;\n    else cout &lt;&lt; &quot;-&quot; &lt;&lt; id &lt;&lt; &quot; &quot;;\n}\n\nbool Litteral::getSigne()\n{\n    return signe;\n}\n\nstring Litteral::getId()\n{\n    return id;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Donnez la d\u00e9finition de la m\u00e9thode <code>egal<\/code>. Cette m\u00e9thode doit retourner <code>true<\/code> si et seulement si le litt\u00e9ral courant (repr\u00e9sent\u00e9 par l&rsquo;instance de <code>Litteral<\/code> avec laquelle la m\u00e9thode est appel\u00e9e) est identique (m\u00eame signe et m\u00eame nom) que celui repr\u00e9sent\u00e9 par <code>autre<\/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++\">bool Litteral::egal(Litteral &amp;autre)\n{\n    return ((signe==autre.getSigne()) &amp;&amp; (id==autre.getId()));\n}\n\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Donnez les lignes de code permettant de r\u00e9aliser les actions suivantes :<\/p>\n<ol>\n<li>D\u00e9clarer une variable <code>w<\/code> initialis\u00e9e avec une instance de <code>Litteral<\/code> repr\u00e9sentant le litt\u00e9ral <code>-x1<\/code>, situ\u00e9e dans la pile.<\/li>\n<li>D\u00e9clarer une variable <code>u<\/code> pointant une instance de <code>Litteral<\/code> situ\u00e9e dans le tas et repr\u00e9sentant le litt\u00e9ral <code>x2<\/code>.<\/li>\n<li>Afficher les litt\u00e9raux d\u00e9sign\u00e9s par <code>w<\/code> et <code>u<\/code>.<\/li>\n<li>Utiliser la m\u00e9thode <code>egal<\/code> pour comparer les deux litt\u00e9raux, et afficher le r\u00e9sultat de la comparaison.<\/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++\">    Litteral w(0, &quot;x1&quot;);\n    Litteral* u = new Litteral(1,&quot;x2&quot;);\n    w.affiche();\n    u-&gt;affiche();\n    cout &lt;&lt; endl &lt;&lt; w.egal(*u) &lt;&lt; endl;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Donnez les lignes de code, faisant suite aux pr\u00e9c\u00e9dentes, permettant d&rsquo;\u00e9changer les litt\u00e9raux d\u00e9sign\u00e9s par <code>w<\/code> et <code>u<\/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++\">    Litteral tmp = w;\n    w = *u;\n    *u = tmp;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4>Exercice d&rsquo;entrainement G.ent2.2<\/h4>\n<p>On appelle <strong>clause<\/strong> un ensemble de litt\u00e9raux. Une clause peut \u00eatre vide ou contenir un litt\u00e9ral ou plusieurs litt\u00e9raux. La classe suivante permet de repr\u00e9senter une clause.<\/p>\n<pre><code class=\"language-c++\">class Clause\n{\nprivate:\n    vector&lt;Litteral&gt; data;\npublic:\n    Clause();\n    Clause(Litteral&amp; w);\n    Clause(Litteral&amp; w1, Litteral&amp; w2);\n    \n    int size();\n    Litteral&amp; getLit(int i);\n    \n    void affiche();\n    bool contient(Litteral&amp; w);\n    void addLit(Litteral&amp; w);\n    void addLit(bool signe, const string&amp; nom);\n    bool egal(Clause&amp; autre);\n};\n<\/code><\/pre>\n<p>Le constructeur par d\u00e9faut cr\u00e9e une clause vide. Les deux autres constructeurs cr\u00e9ent des clauses contenant les litt\u00e9raux d\u00e9sign\u00e9s par leurs param\u00e8tres.<\/p>\n<p>La m\u00e9thode <code>size<\/code> retourne le nombre de litt\u00e9raux de la clause courante et la m\u00e9thode <code>getLit<\/code> retourne le litt\u00e9ral situ\u00e9 en position <code>i<\/code> dans cette clause (c&rsquo;est \u00e0 dire dans le le vecteur d\u00e9sign\u00e9 par l&rsquo;attribut <code>data<\/code>).<\/p>\n<p>La m\u00e9thode <code>contient<\/code> retourne <code>true<\/code> si et seulement si le litt\u00e9ral d\u00e9sign\u00e9 par <code>w<\/code> appartient \u00e0 la clause courante.<\/p>\n<p>Les deux m\u00e9thodes <code>addLit<\/code> permettent d&rsquo;ajouter un nouveau litt\u00e9ral \u00e0 la clause courante, mais seulement si ni ce litt\u00e9ral, ni son oppos\u00e9 ne sont d\u00e9j\u00e0 dans la clause courante.<\/p>\n<p>La m\u00e9thode <code>egal<\/code> d\u00e9termine si la clause courante est identique \u00e0 celle d\u00e9sign\u00e9e par <code>autre<\/code>, c&rsquo;est \u00e0 dire si ces deux clauses comportent exactement les m\u00eames litt\u00e9raux, m\u00eame s&rsquo;ils apparaissent dans des ordres diff\u00e9rents.<\/p>\n<hr>\n<p>Donnez les d\u00e9finitions des trois constructeurs.<\/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++\">Clause::Clause()\n{\n}\n\nClause::Clause(Litteral&amp; w)\n{\n    data.push_back(w);\n}\n\nClause::Clause(Litteral&amp; w1, Litteral&amp; w2)\n{\n    data.push_back(w1);\n    data.push_back(w2);\n}\n<\/code><\/pre>\n<p>L&rsquo;attribut <code>data<\/code> est initialis\u00e9 implicitement par le constructeur par d\u00e9faut de la classe <code>vector<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Donnez les d\u00e9finitions des m\u00e9thodes <code>size<\/code> et <code>getLit<\/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++\">int Clause::size()\n{\n    return (int)data.size();\n}\n\nLitteral&amp; Clause::getLit(int i)\n{\n    return data[i];\n}\n\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Donnez la d\u00e9finition de la m\u00e9thode <code>affiche<\/code>. L&rsquo;affichage d&rsquo;une clause vide doit se faire sous la forme <code>()<\/code>.  Pour une clause non vide, la forme doit \u00eatre <code>(+x1,-x2)<\/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++\">void Clause::affiche()\n{\n    int n = (int)data.size();\n    cout &lt;&lt; &quot;(&quot;;\n    if(n&gt;0)\n    {\n        getLit(0).affiche();\n    }\n    for(int i=1; i&lt;n; i++)\n    {\n        cout &lt;&lt; &quot;,&quot;;\n        getLit(i).affiche();\n    }\n    cout &lt;&lt; &quot;)&quot; &lt;&lt; endl;\n}\n<\/code><\/pre>\n<p>On aurait pu \u00e9crire <code>data[0]<\/code> \u00e0 la place de <code>getLit(0)<\/code>, mais l&rsquo;usage d&rsquo;une m\u00e9thode d&rsquo;acc\u00e8s facilite une \u00e9ventuelle modification ult\u00e9rieure de la repr\u00e9sentation d&rsquo;une clause.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Donnez la d\u00e9finition de la m\u00e9thode <code>contient<\/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++\">bool Clause::contient(Litteral &amp;w)\n{\n    int n = (int)data.size();\n    for(int i=0; i&lt;n; i++)\n    {\n        if (getLit(i).egal(w)) return true;\n    }\n    return false;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Donnez les d\u00e9finitions des deux m\u00e9thodes <code>add<\/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++\">void Clause::addLit(Litteral &amp;w)\n{\n    Litteral negw(!w.getSigne(),w.getId());\n    if(!contient(w) &amp;&amp; !contient(negw))\n    {\n        data.push_back(w);\n    }\n}\n\nvoid Clause::addLit(bool signe, const string&amp; nom)\n{\n    Litteral w(signe, nom);\n    addLit(w);\n}\n<\/code><\/pre>\n<p>De nombreuses variantes sont possibles, y compris une qui utiliserait une m\u00e9thode <code>neg<\/code> qui serait ajout\u00e9e \u00e0 la classe <code>Litteral<\/code> et produirait l&rsquo;oppos\u00e9 du litt\u00e9ral courant. Il est important d&rsquo;\u00e9viter la duplication du code permettant de v\u00e9rifier si le litt\u00e9ral \u00e0 ajouter ou son oppos\u00e9 se trouve d\u00e9j\u00e0 dans la clause. C&rsquo;est pour \u00e9viter une telle duplication de code que la forme \u00e0 deux param\u00e8tres appelle l&rsquo;autre forme de la m\u00e9thode.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Donnez la d\u00e9finition de la m\u00e9thode <code>egal<\/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<p>On consid\u00e8re que chacune des deux clauses \u00e0 comparer ne comporte ni plusieurs occurrences d&rsquo;un m\u00eame litt\u00e9ral, ni un litt\u00e9ral et son oppos\u00e9 (ce qui est v\u00e9rifi\u00e9 lors de l&rsquo;ajout d&rsquo;un litt\u00e9ral avec les m\u00e9thodes <code>addLit<\/code>).<\/p>\n<pre><code class=\"language-c++\">bool Clause::egal(Clause&amp; autre)\n{\n    int n = size();\n    if(n != autre.size()) return false;\n    for(int i=0; i&lt;n; i++)\n    {\n        if(!contient(autre.getLit(i)))\n        {\n            return false;\n        }\n    }\n    return true;\n}\n<\/code><\/pre>\n<p>On s&rsquo;assure que les deux clauses ont le m\u00eame nombre de litt\u00e9raux. Si ne n&rsquo;est pas le cas, on peut imm\u00e9diatement conclure qu&rsquo;elles ne sont pas \u00e9gales. Si c&rsquo;est le cas, il suffit de v\u00e9rifier que chaque litt\u00e9ral d&rsquo;une des clauses est pr\u00e9sent dans l&rsquo;autre.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Donnez les lignes de code permettant de r\u00e9aliser les actions suivantes :<\/p>\n<ol>\n<li>Cr\u00e9er dans deux variables, nomm\u00e9es <code>w<\/code> et <code>u<\/code>, les litt\u00e9raux <code>+x1<\/code> et <code>-x2<\/code>.<\/li>\n<li>Cr\u00e9er dans une variable <code>q1<\/code> la clause contenant les litt\u00e9raux d\u00e9sign\u00e9s par <code>w<\/code> et <code>u<\/code>.<\/li>\n<li>Cr\u00e9er dans une variable <code>q2<\/code> une copie de la clause d\u00e9sign\u00e9e par <code>q1<\/code>.<\/li>\n<li>Tenter d&rsquo;ajouter le litt\u00e9ral <code>+x2<\/code> \u00e0 la clause d\u00e9sign\u00e9e par <code>q1<\/code>. (La clause ne devrait pas \u00eatre modifi\u00e9e car elle contient d\u00e9j\u00e0 l&rsquo;oppos\u00e9 du litt\u00e9ral.)<\/li>\n<li>V\u00e9rifier l&rsquo;\u00e9galit\u00e9 des deux clauses avec la m\u00e9thode <code>egal<\/code> et afficher le r\u00e9sultat (qui devrait \u00eatre 1).<\/li>\n<li>Ajouter le litt\u00e9ral <code>-x3<\/code> \u00e0 la clause d\u00e9sign\u00e9e par <code>q2<\/code>.<\/li>\n<li>V\u00e9rifier l&rsquo;\u00e9galit\u00e9 des deux clauses avec la m\u00e9thode <code>egal<\/code> et afficher le r\u00e9sultat (qui devrait \u00eatre 0).<\/li>\n<li>Afficher les deux clauses.<\/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++\">    Litteral w(1, &quot;x1&quot;);\n    Litteral u(0, &quot;x2&quot;);\n    Clause q1(w, u);\n    Clause q2(q1);\n    q1.addLit(1,&quot;x2&quot;);\n    cout &lt;&lt; q1.egal(q2) &lt;&lt; endl;\n    q2.addLit(0,&quot;x3&quot;);\n    cout &lt;&lt; q1.egal(q2) &lt;&lt; endl;\n    q1.affiche();\n    q2.affiche();\n<\/code><\/pre>\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-332","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\/332","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=332"}],"version-history":[{"count":2,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/332\/revisions"}],"predecessor-version":[{"id":337,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/332\/revisions\/337"}],"wp:attachment":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/media?parent=332"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/categories?post=332"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/tags?post=332"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}