Derniers messages sur Zeste de Savoirhttps://zestedesavoir.com/forums/2022-01-26T18:29:32+01:00Les derniers messages parus sur le forum de Zeste de Savoir.Vector et Visual studio, message #2405652022-01-26T18:29:32+01:00Koda/@Kodahttps://zestedesavoir.com/forums/sujet/15995/vector-et-visual-studio/?page=1#p240565<p>J’ai essayé de désinstaller et de réinstaller Visual Studio pour voir mais ça n’a rien arrangé</p>Vector et Visual studio, message #2404472022-01-21T18:25:01+01:00Koda/@Kodahttps://zestedesavoir.com/forums/sujet/15995/vector-et-visual-studio/?page=1#p240447<p>A ce moment ça m’avait arrangé la situation mais la ça ne change plus rien</p>Vector et Visual studio, message #2404012022-01-20T21:29:21+01:00informaticienzero/@informaticienzerohttps://zestedesavoir.com/forums/sujet/15995/vector-et-visual-studio/?page=1#p240401<p>Dans l’autre topic que tu as créé, le fait d’installer le Kit Windows 10 ne résoud pas l’erreur ? </p>Vector et Visual studio, message #2404002022-01-20T21:22:55+01:00Koda/@Kodahttps://zestedesavoir.com/forums/sujet/15995/vector-et-visual-studio/?page=1#p240400<p>J’ai recréé un projet console expressément pour vérifier et ça me remet la même erreur. J’ai déjà installé et réinstallé Visual studio plusieurs fois avant ce problème mais je ne vois pas ce qui aurait mal pu être installé, dois-je avoir un composant externe spécial d’installé?</p>Vector et Visual studio, message #2403312022-01-20T00:07:59+01:00dalfab/@dalfabhttps://zestedesavoir.com/forums/sujet/15995/vector-et-visual-studio/?page=1#p240331<p>La première erreur dit : "compilateur complétement paumé" c’est inutile de lire les autres erreurs. Ton compilateur ne trouve pas un fichier fondamental 'crtdbg.h’.
Peut-être que Visual s’est mal installé. Il ne trouve pas des données de la console, as-tu bien créé un projet de type console? </p>Vector et Visual studio, message #2403232022-01-19T20:14:42+01:00Koda/@Kodahttps://zestedesavoir.com/forums/sujet/15995/vector-et-visual-studio/?page=1#p240323<p>Voici l’erreur écrite dans la fenêtre "sortie":
L’opération de génération a démarré…
1>——— Début de la génération : Projet : Project4, Configuration : Debug x64 ———
1>Source.cpp
1>C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.30.30705\include\yvals.h(12,10): fatal error C1083: Impossible d’ouvrir le fichier include : 'crtdbg.h' : No such file or directory
1>Génération du projet "Project4.vcxproj" terminée — ÉCHEC.
========== Génération : 0 a réussi, 1 a échoué, 0 à jour, 0 a été ignoré ==========</p>
<p>Dans la section erreurs, il est écrit que mon projet contient 524 erreurs, la plupart étant des erreurs d’ouverture de fichier, les autres étant: </p>
<p>Erreur (active) E0289 aucune instance du constructeur "std::vector<_Ty, _Alloc>::vector [avec _Ty=int, _Alloc=std::allocator<int>]" ne correspond à la liste d’arguments ligne: 11</p>
<p>Erreur (active) E0135 classe "std::vector<int, std::allocator<int>>" n’a pas de membre "push_back" ligne: 13</p>
<p>Erreur (active) E0135 classe "std::vector<int, std::allocator<int>>" n’a pas de membre "push_back" ligne: 15</p>
<p>Erreur (active) E0135 classe "std::vector<int, std::allocator<int>>" n’a pas de membre "push_back" ligne: 16</p>
<p>Erreur (active) E2291 cette instruction 'for' basée sur une plage nécessite une fonction "begin" appropriée et aucune n’a été trouvée ligne: 19</p>
<p>Erreur (active) E0289 aucune instance du constructeur "std::vector<_Ty, _Alloc>::vector [avec _Ty=std::string, _Alloc=std::allocator<std::string>]" ne correspond à la liste d’arguments ligne: 24</p>
<p>Erreur (active) E0135 classe "std::vector<std::string, std::allocator<std::string»" n’a pas de membre "push_back" ligne: 25 </p>
<p>Erreur (active) E2291 cette instruction 'for' basée sur une plage nécessite une fonction "begin" appropriée et aucune n’a été trouvée ligne: 29</p>
<p>Je ne vois vraiment pas à quel endroit j’essaierais d’ajouter un entier à un tableau de chaînes de caractères, de plus j’ai copié-collé le code du cours pour voir où j’aurais pu me tromper.</p>
<p>Au fait j’adore le chat dans votre photo de profil </p>Vector et Visual studio, message #2402632022-01-18T01:40:19+01:00informaticienzero/@informaticienzerohttps://zestedesavoir.com/forums/sujet/15995/vector-et-visual-studio/?page=1#p240263<p>Ton problème vient du fait que tu veux ajouter un entier à un tableau qui contient des chaînes de caractères. C’est comme vouloir ajouter une pomme à une boîte de framboises.</p>
<p>Donc le compilateur te dit qu’il ne trouve pas la fonction <code>push_back</code> ajoutant un entier dans un tableau de chaînes de caractères.</p>Vector et Visual studio, message #2402612022-01-18T00:21:57+01:00dalfab/@dalfabhttps://zestedesavoir.com/forums/sujet/15995/vector-et-visual-studio/?page=1#p240261<p>Bonjour,</p>
<p>Il ne devrait pas y avoir de problème avec ce code. Est-ce bien la première erreur signalée, est-ce indiqué par <em>intellisense</em> ou pendant la compilation? Et il nous faudrait <strong>le texte complet</strong> de la première erreur signalée, à récupérer dans la fenêtre qui s’appelle "output" ou "sortie" après avoir demandé une compilation.</p>Vector et Visual studio, message #2402492022-01-17T20:22:20+01:00Koda/@Kodahttps://zestedesavoir.com/forums/sujet/15995/vector-et-visual-studio/?page=1#p240249<p>J’apprends le C++ grâce au cours proposé sur ce site. J’en suis au chapitre I-7 "Au tableau" où on apprend à se servir des tableaux proposés par C++. J’ai entré le code proposé comme exemple pour la fonction "push_back" mais Visual Studio me dit que la classe n’a pas ce membre. Quelqu’un peut-il me dire comment arrangé ce "petit" problème s’il-vous-plaît? Voici le code:</p>
<div class="hljs-code-div hljs-code-cpp"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span><span data-count="12"></span><span data-count="13"></span><span data-count="14"></span><span data-count="15"></span><span data-count="16"></span><span data-count="17"></span><span data-count="18"></span><span data-count="19"></span><span data-count="20"></span><span data-count="21"></span><span data-count="22"></span><span data-count="23"></span><span data-count="24"></span><span data-count="25"></span><span data-count="26"></span><span data-count="27"></span><span data-count="28"></span><span data-count="29"></span><span data-count="30"></span><span data-count="31"></span><span data-count="32"></span><span data-count="33"></span><span data-count="34"></span><span data-count="35"></span></div><pre><code class="hljs language-cpp"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string"><iostream></span></span>
<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string"><string></span></span>
<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string"><vector></span></span>
<span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> NOMINAX</span>
<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string"><Windows.h></span></span>
<span class="hljs-function"><span class="hljs-keyword">int</span> <span class="hljs-title">main</span><span class="hljs-params">()</span>
</span>{
<span class="hljs-built_in">SetConsoleOutputCP</span>(<span class="hljs-number">1252</span>);
std::vector<<span class="hljs-keyword">int</span>> tableau_de_int{ <span class="hljs-number">12</span>, <span class="hljs-number">24</span> };
<span class="hljs-comment">// On ajoute un élément...</span>
tableau_de_int.<span class="hljs-built_in">push_back</span>(<span class="hljs-number">36</span>);
<span class="hljs-comment">// ...mais on peut en ajouter encore d'autres.</span>
tableau_de_int.<span class="hljs-built_in">push_back</span>(<span class="hljs-number">48</span>);
tableau_de_int.<span class="hljs-built_in">push_back</span>(<span class="hljs-number">100</span>);
<span class="hljs-comment">// On affiche pour vérifier.</span>
<span class="hljs-keyword">for</span> (<span class="hljs-keyword">auto</span> <span class="hljs-keyword">const</span> valeur : tableau_de_int)
{
std::cout << valeur << std::endl;
}
std::vector<std::string> tableau_de_string{ <span class="hljs-string">"Salut !"</span>, <span class="hljs-string">"Voici une phrase."</span> };
tableau_de_string.<span class="hljs-built_in">push_back</span>(<span class="hljs-string">"Mais je vais en ajouter une autre."</span>);
<span class="hljs-comment">// Ceci ne compilera pas.</span>
<span class="hljs-comment">//tableau_de_string.push_back(5);</span>
<span class="hljs-keyword">for</span> (<span class="hljs-keyword">auto</span> <span class="hljs-keyword">const</span> chaine : tableau_de_string)
{
std::cout << chaine << std::endl;
}
<span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;
}
</code></pre></div>[C++] Héritage et vectors, message #1558362017-07-09T19:27:48+02:00p4radox/@p4radoxhttps://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155836<p>Bonsoir, après avoir perdu la raison et fini à l’asile, j’ai enfin compris comment implémenter tout ça et surtout j’ai appris beaucoup de choses <img alt=":D" src="/static/smileys/heureux.png"> (Grâce à vous les gars !)</p>
<p>En re-lisant mes posts, je me rend-compte maintenant de la stupidité de certaines déclarations &gt;_&lt;</p>
<p>J’ai compris comment utiliser ces satanés collections hétérogènes, enfin !
Et j’ai amélioré la conception de mon programme au passage, car la POO c’est cool mais penser en OO quand on vient du C, bah ’C’ la galère, HAHAHahaha… Pardon.</p>
<p>Le truc qui m’a rendu fou en fait c’est que je cherchais à initialiser un truc qui ne peut pas l’être
Bah oui, un <code>std::vector</code> de pointeur unique <code>std::unique_ptr</code> est non copiable (Comparé à un vector de pointeurs partagé <code>std::shared_ptr</code>). Donc le constructeur n’a rien à faire là-dedans, j’ai simplement déclaré un <code>std::vector</code> de type <code>std::unique_ptr</code> en tant que membre <code>private:</code> de la classe <code>Aquarium</code> et quand j’en ai eu besoin dans ma fonction membre pour ajouter un animal de la classe abstraite <code>Animal</code> (Dont dérive une classe <code>Poisson</code>) bah j’utilise <code>.push_back(std::make_unique<Poisson>());</code>, tout simplement !</p>
<p>Olybri m’avait mis la réponse sous les yeux, mais le temps que je comprenne le pricipe…</p>
<p>Donc du coup je vous met le programme ici. Il y a sûrement des choses à améliorer comme la vérification de saisie dans la fonction membre <code>voir()</code> de la classe <code>Aquarium</code>
Parce que si l’on rentre autre chose que un <code>int</code>, la boucle est infinie <img alt=":euh:" src="/static/smileys/unsure.gif"></p>
<p>Et au lieu d’avoir un vieux <code>switch()</code> et de devoir faire des <code>.push_back()</code> dans le constructeur de la classe <code>Aquarium</code> pour définir les valeur possibles, je pourrai mettre ça dans un fichier et initialiser les <code>std::vector</code> contenant les seules possibilités offertes avec ce qu’il y a dans le fichier, comme ça on ne touchera pas au code pour pouvoir ajouter des races d’animaux par la suite.
Mais c’était juste pour voir si j’avais bien compris le tout et que j’implémentai ça correctement.</p>
<p>aquarium.h</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="cp">#ifndef AQUARIUM_H</span>
<span class="cp">#define AQUARIUM_H</span>
<span class="cp">#include</span> <span class="cpf"><vector></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><memory></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><string></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"animal.h"</span><span class="cp"></span>
<span class="k">class</span> <span class="nc">Aquarium</span>
<span class="p">{</span>
<span class="k">private</span><span class="o">:</span>
<span class="c1">// Membres privés</span>
<span class="kt">int</span> <span class="n">m_cycle</span><span class="p">;</span> <span class="c1">// Cycle en cours</span>
<span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="n">m_liste_possible_animaux</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="n">m_liste_possible_vegetaux</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="kt">char</span><span class="o">></span> <span class="n">m_liste_possible_sexes_animaux</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="n">m_liste_possible_regimes_animaux</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">unique_ptr</span><span class="o"><</span><span class="n">anx</span><span class="o">::</span><span class="n">Animal</span><span class="o">::</span><span class="n">Animal</span><span class="o">></span> <span class="o">></span> <span class="n">m_animaux</span><span class="p">;</span> <span class="c1">// Collection d'animaux (Poissons, Crustacés, etc...)</span>
<span class="c1">//std::vector<std::unique_ptr<Vegetal> > m_vegetaux; // Collection de végétaux (Algues, coraux, etc...)</span>
<span class="k">public</span><span class="o">:</span>
<span class="c1">// Ensemble Constructeur/Destructeur</span>
<span class="n">Aquarium</span><span class="p">();</span>
<span class="c1">// Fonctions membres</span>
<span class="kt">void</span> <span class="nf">ajouterAnimal</span><span class="p">();</span>
<span class="kt">void</span> <span class="nf">ajouterVegetal</span><span class="p">();</span>
<span class="kt">void</span> <span class="nf">voir</span><span class="p">();</span>
<span class="kt">void</span> <span class="nf">nouveauCycle</span><span class="p">();</span>
<span class="p">};</span>
<span class="cp">#endif</span>
</pre></div>
</td></tr></table></div>
<p>aquarium.cpp</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="c1">// Headers C++</span>
<span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><string></span><span class="cp"></span>
<span class="c1">// Header de la classe</span>
<span class="cp">#include</span> <span class="cpf">"aquarium.h"</span><span class="cp"></span>
<span class="c1">// Corps de la classe</span>
<span class="n">Aquarium</span><span class="o">::</span><span class="n">Aquarium</span><span class="p">()</span>
<span class="p">{</span>
<span class="n">m_cycle</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="n">m_liste_possible_animaux</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="s">"Poisson"</span><span class="p">);</span>
<span class="n">m_liste_possible_regimes_animaux</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="s">"Carnivore"</span><span class="p">);</span>
<span class="n">m_liste_possible_regimes_animaux</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="s">"Herbivore"</span><span class="p">);</span>
<span class="n">m_liste_possible_sexes_animaux</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="sc">'M'</span><span class="p">);</span>
<span class="n">m_liste_possible_sexes_animaux</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="sc">'F'</span><span class="p">);</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">Aquarium</span><span class="o">::</span><span class="n">ajouterAnimal</span><span class="p">()</span>
<span class="p">{</span>
<span class="c1">// Choix du type d'animal</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Choisissez le type d'animal à ajouter dans l'aquarium (Entrez le numéro) : "</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">for</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">i</span> <span class="p">{</span><span class="mi">0</span><span class="p">}</span> <span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">m_liste_possible_animaux</span><span class="p">.</span><span class="n">size</span><span class="p">()</span> <span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">i</span> <span class="o"><<</span> <span class="s">" : "</span> <span class="o"><<</span> <span class="n">m_liste_possible_animaux</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">">> "</span><span class="p">;</span>
<span class="kt">int</span> <span class="n">choix</span> <span class="p">{</span><span class="mi">0</span><span class="p">},</span> <span class="n">n_race</span> <span class="p">{</span><span class="mi">0</span><span class="p">};</span>
<span class="k">while</span><span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">cin</span> <span class="o">>></span> <span class="n">choix</span><span class="p">)</span> <span class="o">&&</span> <span class="n">choix</span> <span class="o">></span> <span class="k">static_cast</span><span class="o"><</span><span class="kt">int</span><span class="o">></span><span class="p">(</span><span class="n">m_liste_possible_animaux</span><span class="p">.</span><span class="n">size</span><span class="p">()))</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="s">"La saisie n</span><span class="se">\'</span><span class="s">est pas valide !"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">race</span> <span class="p">{</span><span class="n">m_liste_possible_animaux</span><span class="p">[</span><span class="n">choix</span><span class="p">]};</span>
<span class="n">n_race</span> <span class="o">=</span> <span class="n">choix</span><span class="p">;</span>
<span class="c1">// Saisie de l'espèce</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Entrez l</span><span class="se">\'</span><span class="s">espèce de l</span><span class="se">\'</span><span class="s">animal : "</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">">> "</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">entree</span> <span class="p">{</span><span class="s">""</span><span class="p">};</span>
<span class="k">while</span><span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">cin</span> <span class="o">>></span> <span class="n">entree</span><span class="p">))</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="s">"La saisie n</span><span class="se">\'</span><span class="s">est pas valide !"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">espece</span> <span class="p">{</span><span class="n">entree</span><span class="p">};</span>
<span class="c1">// Choix du type de régime alimentaire</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Choisissez le régime alimentaire de l</span><span class="se">\'</span><span class="s">animal (Entrez le numéro) : "</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">for</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">i</span> <span class="p">{</span><span class="mi">0</span><span class="p">}</span> <span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">m_liste_possible_regimes_animaux</span><span class="p">.</span><span class="n">size</span><span class="p">()</span> <span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">i</span> <span class="o"><<</span> <span class="s">" : "</span> <span class="o"><<</span> <span class="n">m_liste_possible_regimes_animaux</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">">> "</span><span class="p">;</span>
<span class="n">choix</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="k">while</span><span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">cin</span> <span class="o">>></span> <span class="n">choix</span><span class="p">)</span> <span class="o">&&</span> <span class="n">choix</span> <span class="o">></span> <span class="k">static_cast</span><span class="o"><</span><span class="kt">int</span><span class="o">></span><span class="p">(</span><span class="n">m_liste_possible_regimes_animaux</span><span class="p">.</span><span class="n">size</span><span class="p">()))</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="s">"La saisie n</span><span class="se">\'</span><span class="s">est pas valide !"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">regime</span> <span class="p">{</span><span class="n">m_liste_possible_regimes_animaux</span><span class="p">[</span><span class="n">choix</span><span class="p">]};</span>
<span class="c1">// Choix du sexe</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Choisissez le sexe de l</span><span class="se">\'</span><span class="s">animal (Entrez le numéro) : "</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">for</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">i</span> <span class="p">{</span><span class="mi">0</span><span class="p">}</span> <span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">m_liste_possible_sexes_animaux</span><span class="p">.</span><span class="n">size</span><span class="p">()</span> <span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">i</span> <span class="o"><<</span> <span class="s">" : "</span> <span class="o"><<</span> <span class="n">m_liste_possible_sexes_animaux</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">">> "</span><span class="p">;</span>
<span class="n">choix</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="k">while</span><span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">cin</span> <span class="o">>></span> <span class="n">choix</span><span class="p">)</span> <span class="o">&&</span> <span class="n">choix</span> <span class="o">></span> <span class="k">static_cast</span><span class="o"><</span><span class="kt">int</span><span class="o">></span><span class="p">(</span><span class="n">m_liste_possible_sexes_animaux</span><span class="p">.</span><span class="n">size</span><span class="p">()))</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="s">"La saisie n</span><span class="se">\'</span><span class="s">est pas valide !"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">char</span> <span class="n">sexe</span> <span class="p">{</span><span class="n">m_liste_possible_sexes_animaux</span><span class="p">[</span><span class="n">choix</span><span class="p">]};</span>
<span class="c1">// Saisie du nom</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Entrez le nom de l</span><span class="se">\'</span><span class="s">animal : "</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">">> "</span><span class="p">;</span>
<span class="n">entree</span> <span class="o">=</span> <span class="s">""</span><span class="p">;</span>
<span class="k">while</span><span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">cin</span> <span class="o">>></span> <span class="n">entree</span><span class="p">))</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="s">"La saisie n</span><span class="se">\'</span><span class="s">est pas valide !"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">nom</span> <span class="p">{</span><span class="n">entree</span><span class="p">};</span>
<span class="c1">// Saisie de l'âge</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Entrez l</span><span class="se">\'</span><span class="s">âge de l</span><span class="se">\'</span><span class="s">animal (0 pour un nouveau-né) : "</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">">> "</span><span class="p">;</span>
<span class="n">choix</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="k">while</span><span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">cin</span> <span class="o">>></span> <span class="n">choix</span><span class="p">))</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="s">"La saisie n</span><span class="se">\'</span><span class="s">est pas valide !"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">int</span> <span class="n">age</span> <span class="p">{</span><span class="n">choix</span><span class="p">};</span>
<span class="k">switch</span><span class="p">(</span><span class="n">n_race</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">case</span> <span class="mi">0</span><span class="o">:</span>
<span class="n">m_animaux</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">make_unique</span><span class="o"><</span><span class="n">anx</span><span class="o">::</span><span class="n">Poisson</span><span class="o">::</span><span class="n">Poisson</span><span class="o">></span><span class="p">(</span><span class="n">sexe</span><span class="p">,</span> <span class="n">age</span><span class="p">,</span> <span class="n">race</span><span class="p">,</span> <span class="n">regime</span><span class="p">,</span> <span class="n">nom</span><span class="p">,</span> <span class="n">espece</span><span class="p">));</span>
<span class="k">break</span><span class="p">;</span>
<span class="k">default</span><span class="o">:</span>
<span class="k">break</span><span class="p">;</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">Aquarium</span><span class="o">::</span><span class="n">ajouterVegetal</span><span class="p">()</span>
<span class="p">{</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">Aquarium</span><span class="o">::</span><span class="n">voir</span><span class="p">()</span>
<span class="p">{</span>
<span class="k">for</span><span class="p">(</span><span class="k">auto</span> <span class="o">&</span> <span class="nl">animal</span> <span class="p">:</span> <span class="n">m_animaux</span><span class="p">)</span>
<span class="n">animal</span><span class="o">-></span><span class="n">voir</span><span class="p">();</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">Aquarium</span><span class="o">::</span><span class="n">nouveauCycle</span><span class="p">()</span>
<span class="p">{</span>
<span class="p">}</span>
</pre></div>
</td></tr></table></div>
<p>animal.h</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="cp">#ifndef ANIMAL_H</span>
<span class="cp">#define ANIMAL_H</span>
<span class="cp">#include</span> <span class="cpf"><string></span><span class="cp"></span>
<span class="k">namespace</span> <span class="n">anx</span>
<span class="p">{</span>
<span class="k">class</span> <span class="nc">Animal</span>
<span class="p">{</span>
<span class="k">private</span><span class="o">:</span>
<span class="c1">// Membres</span>
<span class="kt">char</span> <span class="n">m_sexe</span><span class="p">;</span>
<span class="kt">int</span> <span class="n">m_age</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">m_race</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">m_regime</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">m_nom</span><span class="p">;</span>
<span class="k">protected</span><span class="o">:</span>
<span class="c1">// Getters</span>
<span class="kt">char</span> <span class="n">Sexe</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">m_sexe</span><span class="p">;</span> <span class="p">};</span>
<span class="kt">int</span> <span class="nf">Age</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">m_age</span><span class="p">;</span> <span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Race</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">m_race</span><span class="p">;</span> <span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Regime</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">m_regime</span><span class="p">;</span> <span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Nom</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">m_nom</span><span class="p">;</span> <span class="p">};</span>
<span class="k">public</span><span class="o">:</span>
<span class="c1">// Ensemble Constructeur/Destructeur</span>
<span class="n">Animal</span><span class="p">(</span><span class="kt">char</span> <span class="n">sexe</span> <span class="o">=</span> <span class="sc">'U'</span><span class="p">,</span> <span class="kt">int</span> <span class="n">age</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">race</span> <span class="o">=</span> <span class="s">"Inconnue"</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">regime</span> <span class="o">=</span> <span class="s">"Inconnu"</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">nom</span> <span class="o">=</span> <span class="s">"Inconnu"</span><span class="p">)</span>
<span class="o">:</span> <span class="n">m_sexe</span><span class="p">(</span><span class="n">sexe</span><span class="p">),</span> <span class="n">m_age</span><span class="p">(</span><span class="n">age</span><span class="p">),</span> <span class="n">m_race</span><span class="p">(</span><span class="n">race</span><span class="p">),</span> <span class="n">m_regime</span><span class="p">(</span><span class="n">regime</span><span class="p">),</span> <span class="n">m_nom</span><span class="p">(</span><span class="n">nom</span><span class="p">)</span> <span class="p">{}</span> <span class="p">;</span>
<span class="k">virtual</span> <span class="o">~</span><span class="n">Animal</span><span class="p">()</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
<span class="c1">// Fonctions membres</span>
<span class="k">virtual</span> <span class="kt">void</span> <span class="nf">voir</span><span class="p">()</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="k">virtual</span> <span class="kt">void</span> <span class="nf">seNourrir</span><span class="p">()</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">};</span>
<span class="k">class</span> <span class="nc">Poisson</span> <span class="o">:</span> <span class="k">public</span> <span class="n">Animal</span>
<span class="p">{</span>
<span class="k">private</span><span class="o">:</span>
<span class="c1">// Membres</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">m_espece</span><span class="p">;</span>
<span class="k">protected</span><span class="o">:</span>
<span class="c1">// Getters</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Espece</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">m_espece</span><span class="p">;</span> <span class="p">};</span>
<span class="k">public</span><span class="o">:</span>
<span class="c1">// Constructeur</span>
<span class="n">Poisson</span><span class="p">(</span><span class="kt">char</span> <span class="n">sexe</span> <span class="o">=</span> <span class="sc">'U'</span><span class="p">,</span> <span class="kt">int</span> <span class="n">age</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">race</span> <span class="o">=</span> <span class="s">"Inconnue"</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">regime</span> <span class="o">=</span> <span class="s">"Inconnu"</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">nom</span> <span class="o">=</span> <span class="s">"Inconnu"</span><span class="p">,</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">espece</span> <span class="o">=</span> <span class="s">"Inconnue"</span><span class="p">)</span> <span class="o">:</span> <span class="n">Animal</span><span class="p">(</span><span class="n">sexe</span><span class="p">,</span> <span class="n">age</span><span class="p">,</span> <span class="n">race</span><span class="p">,</span> <span class="n">regime</span><span class="p">,</span> <span class="n">nom</span><span class="p">),</span> <span class="n">m_espece</span><span class="p">(</span><span class="n">espece</span><span class="p">)</span> <span class="p">{}</span> <span class="p">;</span>
<span class="c1">// Fonctions membres</span>
<span class="k">virtual</span> <span class="kt">void</span> <span class="nf">voir</span><span class="p">()</span> <span class="k">override</span><span class="p">;</span>
<span class="k">virtual</span> <span class="kt">void</span> <span class="nf">seNourrir</span><span class="p">()</span> <span class="k">override</span><span class="p">;</span>
<span class="p">};</span>
<span class="p">}</span>
<span class="cp">#endif</span>
</pre></div>
</td></tr></table></div>
<p>animal.cpp</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="c1">// Headers C++</span>
<span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
<span class="c1">// Header de la classe</span>
<span class="cp">#include</span> <span class="cpf">"animal.h"</span><span class="cp"></span>
<span class="c1">// Corps de la classe</span>
<span class="kt">void</span> <span class="n">anx</span><span class="o">::</span><span class="n">Poisson</span><span class="o">::</span><span class="n">voir</span><span class="p">()</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Race : "</span> <span class="o"><<</span> <span class="n">Race</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Espèce : "</span> <span class="o"><<</span> <span class="n">Espece</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Régime alimentaire : "</span> <span class="o"><<</span> <span class="n">Regime</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Sexe : "</span> <span class="o"><<</span> <span class="n">Sexe</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Nom : "</span> <span class="o"><<</span> <span class="n">Nom</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Âge : "</span> <span class="o"><<</span> <span class="n">Age</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">anx</span><span class="o">::</span><span class="n">Poisson</span><span class="o">::</span><span class="n">seNourrir</span><span class="p">()</span>
<span class="p">{</span>
<span class="p">}</span>
</pre></div>
</td></tr></table></div>
<p>En tout cas, merci à tous pour votre aide, je vais pouvoir continuer l’exercice du javaquarium tout en apprenant, car il n’y a qu’en pratiquant et en découvrant au fur et à mesure que je peux comprendre et retenir les choses, si je lisait le Primer de A à Z direct, j’aurai rien retenu, alors que là en posant des questions, en relisant le cours et en cherchant (beaucoup) de mon côté, j’arrive à mes fins.</p>
<p>Merci encore !</p>
<hr>
<p>PS: Je reviendrai sûrement vous embêter encore si y’a encore des montagnes après celle-là <img alt=":lol:" src="/static/smileys/rire.gif"></p>[C++] Héritage et vectors, message #1557772017-07-09T14:27:19+02:00p4radox/@p4radoxhttps://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155777<p>D’accord pour le cast, c’est vrai que la taille d’un vector est de type <code>std::size_t</code> donc pourquoi ne pas déclarer <code>i</code> du même type dans le <code>for</code>, c’est pas faux, merci.</p>
<p>J’ai recommencé tout le programme, en essayant de faire plus propre.
J’ai donc maintenant une classe mère abstraite <code>Animal</code> dont tout va dériver (C’était stupide de créer une classe Herbivore ou Carnivore, y’a pas que les poissons qui on ce régime dans la vie. En gros je me suis inspiré du réel pour penser en OO)</p>
<p>Par contre, là ou je galère mais à mort, c’est dans l’utilisation d’une collection hétérogène.</p>
<p>En fait dans ma classe <code>Aquarium</code> j’ai un vector suivant : <code>std::vector<std::unique_ptr<Animal> > animaux;</code> qui est un membre de cette classe <code>Aquarium</code>, et donc j’ai compris que si l’on veut stocker des poissons et des moules dans la collection hétérogène animale, il fallait une classe abstraite de base (Donc la classe <code>Animal</code> qui a au moins une fonction membre virtuelle pure).</p>
<p>Mais ce que je ne comprends pas c’est comment travailler avec cette collection (Je sais que l’on ne peut pas la copier car on ne peut pas copier des <code>std::unique_ptr</code>). Coment initialiser une collection hétérogène dans un constructeur ? (dans le constructeur de la classe <code>Aquarium</code>)</p>[C++] Héritage et vectors, message #1557662017-07-09T12:49:44+02:00Ksass`Peuk/@Ksass%60Peukhttps://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155766<p><strong>@p4radox</strong> : Tu n’as pas besoin de stocker le régime dans le poisson puisque c’est son type final qui va le définir. Là en plus, ta classe m’autorise à créer un poisson carnivore en lui transmettant comme régime "herbivore" ou "aeiflaeruhmih".</p>
<figure>
<blockquote>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="p">{</span><span class="mi">0</span><span class="p">}</span> <span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="n">m_poissons</span><span class="p">.</span><span class="n">size</span><span class="p">()</span> <span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span>
</pre></div>
</td></tr></table></div>
</blockquote>
<figcaption><a href="https://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155758">p4radox</a></figcaption>
</figure>
<p>Première chose : n’utilise pas les casts façon langage C, seconde chose, plutôt que faire ce cast pas propre du tout, utilise le bon type pour la variable <code>i</code> : <code>std::size_t</code>. Quand ton destructeur ne fait rien, contente toi de ne pas le mettre quand il n’est pas virtuel, et quand il est virtuel, tu peux utiliser le <code>= default</code>.</p>[C++] Héritage et vectors, message #1557582017-07-09T11:14:37+02:00p4radox/@p4radoxhttps://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155758<p>Bonjour à tous,
La nuit porte conseil apparement, du coup je pense que c’est plutôt un gros problème de conception que j’ai et je suis en train de tout reprendre à zéro. J’ai aussi l’impression d’avoir encore une partie du cerveau ancrée dans le language C et je n’arrive pas à vraiment penser en OO.</p>
<p>Dès que j’aurais tout ré-implanté, je vous posterez mon travail.</p>
<p>Bonne journée à tous.</p>[C++] Héritage et vectors, message #1556832017-07-08T17:37:49+02:00p4radox/@p4radoxhttps://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155683<p>J’ai essayé d’implanter ça comme tu le décris dans cet exemple, en passant aux constructeurs filles un objet par référence de type de la classe mère.</p>
<p>Tout fonctionne sans erreurs sauf que dans mon vector, ce sont des objets mère et non des objets filles.
Comment faire comprendre au compilateur que je veux dans un vector des objets filles de type différents sachant que normalement un vector ne contient qu’un seul type d’objet dans sa collection ?</p>
<p>En gros, un vector de type classe mère composé d’objets fille1 ou fille2 ou du coup je peux appeller une fonction membre sur les elements et grâce au mot clé virtual, le compilateur comprendrais de quelle classe il s’agit.</p>
<p><del>Je dirais bien les templates mais j’ai peur de dire une connerie.</del> C’était une connerie</p>
<hr>
<p>EDIT : Je vais vous montrer ce que j’ai fait, comme ça vous perdrez moins de temps</p>
<p><code>poisson.h</code></p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="cp">#ifndef POISSON_H</span>
<span class="cp">#define POISSON_H</span>
<span class="k">class</span> <span class="nc">Poisson</span>
<span class="p">{</span>
<span class="k">private</span><span class="o">:</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">m_nom</span><span class="p">;</span>
<span class="kt">char</span> <span class="n">m_sexe</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">m_regime</span><span class="p">;</span>
<span class="k">protected</span><span class="o">:</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Nom</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">m_nom</span><span class="p">;</span> <span class="p">};</span>
<span class="kt">char</span> <span class="nf">Sexe</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">m_sexe</span><span class="p">;</span> <span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">Regime</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">m_regime</span><span class="p">;</span> <span class="p">};</span>
<span class="k">public</span><span class="o">:</span>
<span class="n">Poisson</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">nom</span> <span class="o">=</span> <span class="s">"Poisson"</span><span class="p">,</span> <span class="kt">char</span> <span class="n">sexe</span> <span class="o">=</span> <span class="sc">'A'</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">regime</span> <span class="o">=</span> <span class="s">"Inconnu"</span><span class="p">);</span>
<span class="k">virtual</span> <span class="o">~</span><span class="n">Poisson</span><span class="p">()</span> <span class="p">{};</span>
<span class="k">virtual</span> <span class="kt">void</span> <span class="nf">afficher</span><span class="p">()</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="k">virtual</span> <span class="kt">void</span> <span class="nf">nourrir</span><span class="p">()</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">};</span>
<span class="k">class</span> <span class="nc">Carnivore</span> <span class="o">:</span> <span class="k">public</span> <span class="n">Poisson</span>
<span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
<span class="n">Carnivore</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">nom</span><span class="p">,</span> <span class="kt">char</span> <span class="n">sexe</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">regime</span><span class="p">);</span>
<span class="k">virtual</span> <span class="o">~</span><span class="n">Carnivore</span><span class="p">()</span> <span class="p">{};</span>
<span class="kt">void</span> <span class="nf">afficher</span><span class="p">();</span>
<span class="kt">void</span> <span class="nf">nourrir</span><span class="p">();</span>
<span class="p">};</span>
<span class="k">class</span> <span class="nc">Herbivore</span> <span class="o">:</span> <span class="k">public</span> <span class="n">Poisson</span>
<span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
<span class="n">Herbivore</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">nom</span><span class="p">,</span> <span class="kt">char</span> <span class="n">sexe</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">regime</span><span class="p">);</span>
<span class="k">virtual</span> <span class="o">~</span><span class="n">Herbivore</span><span class="p">()</span> <span class="p">{};</span>
<span class="kt">void</span> <span class="nf">afficher</span><span class="p">();</span>
<span class="kt">void</span> <span class="nf">nourrir</span><span class="p">();</span>
<span class="p">};</span>
<span class="cp">#endif</span>
</pre></div>
</td></tr></table></div>
<p><code>poisson.cpp</code></p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><string></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"algue.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"poisson.h"</span><span class="cp"></span>
<span class="c1">// Classe Poisson</span>
<span class="n">Poisson</span><span class="o">::</span><span class="n">Poisson</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">nom</span><span class="p">,</span> <span class="kt">char</span> <span class="n">sexe</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">regime</span><span class="p">)</span> <span class="o">:</span> <span class="n">m_nom</span><span class="p">(</span><span class="n">nom</span><span class="p">),</span> <span class="n">m_sexe</span><span class="p">(</span><span class="n">sexe</span><span class="p">),</span> <span class="n">m_regime</span><span class="p">(</span><span class="n">regime</span><span class="p">)</span>
<span class="p">{</span>
<span class="p">}</span>
<span class="c1">// Classe Carnivore</span>
<span class="n">Carnivore</span><span class="o">::</span><span class="n">Carnivore</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">nom</span><span class="p">,</span> <span class="kt">char</span> <span class="n">sexe</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">regime</span><span class="p">)</span> <span class="o">:</span> <span class="n">Poisson</span><span class="p">(</span><span class="n">nom</span><span class="p">,</span> <span class="n">sexe</span><span class="p">,</span> <span class="n">regime</span><span class="p">)</span>
<span class="p">{</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">Carnivore</span><span class="o">::</span><span class="n">afficher</span><span class="p">()</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Nom : "</span> <span class="o"><<</span> <span class="n">Nom</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Sexe : "</span> <span class="o"><<</span> <span class="n">Sexe</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Régime : "</span> <span class="o"><<</span> <span class="n">Regime</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="c1">// Classe Herbivore</span>
<span class="n">Herbivore</span><span class="o">::</span><span class="n">Herbivore</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">nom</span><span class="p">,</span> <span class="kt">char</span> <span class="n">sexe</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">regime</span><span class="p">)</span> <span class="o">:</span> <span class="n">Poisson</span><span class="p">(</span><span class="n">nom</span><span class="p">,</span> <span class="n">sexe</span><span class="p">,</span> <span class="n">regime</span><span class="p">)</span>
<span class="p">{</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">Herbivore</span><span class="o">::</span><span class="n">afficher</span><span class="p">()</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Nom : "</span> <span class="o"><<</span> <span class="n">Nom</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Sexe : "</span> <span class="o"><<</span> <span class="n">Sexe</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Régime : "</span> <span class="o"><<</span> <span class="n">Regime</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
</td></tr></table></div>
<p><code>aquarium.h</code></p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="cp">#ifndef AQUARIUM_H</span>
<span class="cp">#define AQUARIUM_H</span>
<span class="cp">#include</span> <span class="cpf"><vector></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><memory></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"algue.h"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"poisson.h"</span><span class="cp"></span>
<span class="k">class</span> <span class="nc">Aquarium</span>
<span class="p">{</span>
<span class="k">private</span><span class="o">:</span>
<span class="kt">int</span> <span class="n">m_cycles</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">unique_ptr</span><span class="o"><</span><span class="n">Poisson</span><span class="o">>></span> <span class="n">m_poissons</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">Algue</span><span class="o">::</span><span class="n">Algue</span><span class="o">></span> <span class="n">m_algues</span><span class="p">;</span>
<span class="k">public</span><span class="o">:</span>
<span class="n">Aquarium</span><span class="p">();</span>
<span class="o">~</span><span class="n">Aquarium</span><span class="p">();</span>
<span class="kt">void</span> <span class="nf">ajouterPoisson</span><span class="p">();</span>
<span class="kt">void</span> <span class="nf">ajouterAlgue</span><span class="p">();</span>
<span class="kt">void</span> <span class="nf">nouveauCycle</span><span class="p">();</span>
<span class="p">};</span>
<span class="cp">#endif</span>
</pre></div>
</td></tr></table></div>
<p><code>aquarium.cpp</code></p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="c1">// Headers C++</span>
<span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><string></span><span class="cp"></span>
<span class="c1">// Classes</span>
<span class="cp">#include</span> <span class="cpf">"aquarium.h"</span><span class="cp"></span>
<span class="c1">// Corps de la classe Aquarium</span>
<span class="n">Aquarium</span><span class="o">::</span><span class="n">Aquarium</span><span class="p">()</span> <span class="c1">// Constructeur</span>
<span class="p">{</span>
<span class="n">m_cycles</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="n">m_algues</span> <span class="o">=</span> <span class="p">{};</span>
<span class="p">}</span>
<span class="n">Aquarium</span><span class="o">::~</span><span class="n">Aquarium</span><span class="p">()</span> <span class="c1">// Destructeur</span>
<span class="p">{</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">Aquarium</span><span class="o">::</span><span class="n">ajouterPoisson</span><span class="p">()</span>
<span class="p">{</span>
<span class="kt">char</span> <span class="n">fin_ajout</span> <span class="p">{</span><span class="mi">1</span><span class="p">};</span>
<span class="k">do</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Entrez le nom du poisson : "</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">nom</span> <span class="p">{</span><span class="s">"Poisson"</span><span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cin</span> <span class="o">>></span> <span class="n">nom</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Entrez le sexe du poisson (M/F) : "</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cin</span><span class="p">.</span><span class="n">get</span><span class="p">();</span>
<span class="kt">char</span> <span class="n">sexe</span> <span class="p">{</span><span class="sc">'I'</span><span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cin</span> <span class="o">>></span> <span class="n">sexe</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Entrez le régime alimentaire du poisson : "</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">regime</span> <span class="p">{</span><span class="s">""</span><span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cin</span> <span class="o">>></span> <span class="n">regime</span><span class="p">;</span>
<span class="k">if</span><span class="p">(</span><span class="n">regime</span> <span class="o">==</span> <span class="s">"Carnivore"</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">m_poissons</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">make_unique</span><span class="o"><</span><span class="n">Carnivore</span><span class="o">></span><span class="p">(</span><span class="n">nom</span><span class="p">,</span> <span class="n">sexe</span><span class="p">,</span> <span class="n">regime</span><span class="p">));</span>
<span class="p">}</span>
<span class="k">else</span> <span class="k">if</span><span class="p">(</span><span class="n">regime</span> <span class="o">==</span> <span class="s">"Herbivore"</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">m_poissons</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">make_unique</span><span class="o"><</span><span class="n">Herbivore</span><span class="o">></span><span class="p">(</span><span class="n">nom</span><span class="p">,</span> <span class="n">sexe</span><span class="p">,</span> <span class="n">regime</span><span class="p">));</span>
<span class="p">}</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="kt">char</span> <span class="n">choix</span> <span class="p">{</span><span class="sc">'O'</span><span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Voulez-vous ajouter un autre poisson ?(O/N) : "</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cin</span> <span class="o">>></span> <span class="n">choix</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">if</span> <span class="p">(</span><span class="n">choix</span> <span class="o">==</span> <span class="sc">'N'</span><span class="p">)</span>
<span class="n">fin_ajout</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span><span class="k">while</span><span class="p">(</span><span class="n">fin_ajout</span><span class="p">);</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">Aquarium</span><span class="o">::</span><span class="n">ajouterAlgue</span><span class="p">()</span>
<span class="p">{</span>
<span class="kt">char</span> <span class="n">fin_ajout</span> <span class="p">{</span><span class="mi">1</span><span class="p">};</span>
<span class="k">do</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Entrez le nombre d</span><span class="se">\'</span><span class="s">algues à ajouter : "</span><span class="p">;</span>
<span class="kt">int</span> <span class="n">nb_algues</span> <span class="p">{</span><span class="mi">0</span><span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cin</span> <span class="o">>></span> <span class="n">nb_algues</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="p">{</span><span class="mi">0</span><span class="p">}</span> <span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">nb_algues</span> <span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">Algue</span><span class="o">::</span><span class="n">Algue</span> <span class="n">a</span><span class="p">(</span><span class="s">"Algue"</span><span class="p">);</span>
<span class="n">m_algues</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">a</span><span class="p">);</span>
<span class="p">}</span>
<span class="kt">char</span> <span class="n">choix</span> <span class="p">{</span><span class="sc">'O'</span><span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Voulez-vous ajouter d</span><span class="se">\'</span><span class="s">autres algues ?(O/N) : "</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cin</span> <span class="o">>></span> <span class="n">choix</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">if</span> <span class="p">(</span><span class="n">choix</span> <span class="o">==</span> <span class="sc">'N'</span><span class="p">)</span>
<span class="n">fin_ajout</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span><span class="k">while</span><span class="p">(</span><span class="n">fin_ajout</span><span class="p">);</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">Aquarium</span><span class="o">::</span><span class="n">nouveauCycle</span><span class="p">()</span>
<span class="p">{</span>
<span class="n">m_cycles</span><span class="o">++</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"CYCLE #"</span> <span class="o"><<</span> <span class="n">m_cycles</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"----------"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Poissons : "</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="p">{</span><span class="mi">0</span><span class="p">}</span> <span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="n">m_poissons</span><span class="p">.</span><span class="n">size</span><span class="p">()</span> <span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">m_poissons</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">-></span><span class="n">afficher</span><span class="p">();</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Algues : "</span> <span class="o"><<</span> <span class="n">m_algues</span><span class="p">.</span><span class="n">size</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
</td></tr></table></div>
<hr>
<p>EDIT 2 : Bon, en parcourant le net, j’ai appris deux trois choses en plus et je pense commencer piger le truc.</p>
<ul>
<li>En utilisant un pointeur intelligent pour créer une collection d’objets dérivés (unique_ptr ou shared_ptr), on respecte le principe RAII donc aucun risque de fuite mémoire en comparaison à l’utilisation des pointeurs Raw (Les pointeurs du C quoi).</li>
<li>J’ai entendu parler de collection hétérogène, c’est exactement ce que je cherche à faire, grâce aux pointeurs intelligents sachant que mes deux classes filles sont identiques donc au niveau de la conception c’est correct.</li>
<li>Le polymorphisme est le fait de faire changer de forme (Morphing quoi) mais ce changement va s’opérer plusieures fois. Donc comme ma classe Poisson peut devenir une classe Carnivore ou Herbivore, on arle bien de polymorphisme.
Sinon, c’est juste un héritage.</li>
<li>Cependant, mon vector d’objets est déclaré dans le constructeur de la classe Aquarium (Bah oui, les poissons (Carnivores ou Herbivores ne s’auto-contiennent pas, c’est l’aquarium qui les contient, d’ou ma collection car je ne sais pas combien de poissons je vais ajouter). Mais que dois-je mettre dans l’implémentation du constructeur explicite (Soit dans aquarium.ccp) afin d’initialiser ce vector ? A moins que je fasse fausse route sur ça.<code>std::move</code> à l’air d’être la solution à ce problème mais je n’ai pas compris un traitre mot de son utilisation</li>
</ul>
<p>Je n’ai qu’une erreur à la compilation : <code>référence indéfinie vers vtable</code>
Et ce pour chaque classe fille.</p>
<h4>Merci pour vos réponses et d’avoir pris le temps de m’aider déjà, comprendre ce language en autodidacte n’est pas une chose aisée mais c’est important pour moi.</h4>[C++] Héritage et vectors, message #1556772017-07-08T17:08:59+02:00Olybri/@Olybrihttps://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155677<figure>
<blockquote>
<p>Par contre, est-ce que dans une classe abstraite on peux mettre des membres que la classe concrète peut ré-utiliser ou alors une classe abstraite n’est qu’un concept abstrait justement et toute l’implémentation se fait dans les classes concrètes ?</p>
<p>[…]</p>
<p>Une classe abstraite n’a pas de constructeur logiquement alors, si ?</p>
</blockquote>
<figcaption><a href="https://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155652">p4radox</a></figcaption>
</figure>
<p>Non, une classe abstraite peut parfaitement avoir un constructeur, des variables membres et des fonctions définies. Une classe est dite abstraite dès le moment qu’<strong>au moins une</strong> de ses fonctions membres est abstraite, ce qui rend l’instanciation impossible.</p>
<p>Java (qui est un langage qui se base énormément sur la POO) utilise également la notion d’<strong>interface</strong> pour une classe qui est non seulement abstraite, mais qui contient uniquement des fonctions abstraites<sup id="fnref-1"><a class="footnote-ref" href="#fn-1">1</a></sup> et aucune variable.</p>
<p>Il faut également savoir que l’on peut dériver d’une classe qui n’est pas abstraite. Pour notre exemple, on aurait donc très bien pu ajouter un constructeur et des fonctions définies.</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="k">struct</span> <span class="n">Animal</span>
<span class="p">{</span>
<span class="n">Animal</span><span class="p">(</span><span class="kt">float</span> <span class="n">taille</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">m_taille</span> <span class="o">=</span> <span class="n">taille</span><span class="p">;</span>
<span class="p">}</span>
<span class="c1">// avec 'virtual', on indique ce que cette fonction peut être redéfinie dans une sous-classe</span>
<span class="k">virtual</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">cri</span><span class="p">()</span>
<span class="p">{</span>
<span class="k">return</span> <span class="s">"cri par défaut"</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">private</span><span class="o">:</span>
<span class="kt">float</span> <span class="n">m_taille</span><span class="p">;</span>
<span class="p">};</span>
</pre></div>
</td></tr></table></div>
<p>Avec ce code, il est donc possible d’instancier un objet de type <code>Animal</code>, et les sous-classes ne sont plus obligées de redéfinir la fonction <code>cri</code>.</p>
<p>En revanche, comme <code>Animal</code> possède désormais un constructeur avec un paramètre (et pas de constructeur par défaut), les sous-classes sont obligées d’appeler explicitement ce constructeur, soit en définissant un constructeur semblable :</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3
4
5
6</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="k">struct</span> <span class="nl">Chien</span> <span class="p">:</span> <span class="n">Animal</span>
<span class="p">{</span>
<span class="n">Chien</span><span class="p">(</span><span class="kt">float</span> <span class="n">taille</span><span class="p">)</span> <span class="o">:</span> <span class="n">Animal</span><span class="p">(</span><span class="n">taille</span><span class="p">)</span>
<span class="p">{</span>
<span class="p">}</span>
<span class="p">};</span>
</pre></div>
</td></tr></table></div>
<p>Soit en définissant un constructeur par défaut :</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3
4
5
6</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="k">struct</span> <span class="nl">Chien</span> <span class="p">:</span> <span class="n">Animal</span>
<span class="p">{</span>
<span class="n">Chien</span><span class="p">()</span> <span class="o">:</span> <span class="n">Animal</span><span class="p">(</span><span class="mf">1.5</span><span class="p">)</span>
<span class="p">{</span>
<span class="p">}</span>
<span class="p">};</span>
</pre></div>
</td></tr></table></div>
<figure>
<blockquote>
<p>En revanche, <code>unique_ptr</code> je n’ai jamais vu ce truc, qu’est-ce que c’est ?</p>
</blockquote>
<figcaption><a href="https://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155652">p4radox</a></figcaption>
</figure>
<p>Il s’agit simplement d’un objet qui représente un pointeur en suivant le principe RAII (en gros, la durée de vie de la resource pointée est la même que celle du pointeur). Cela permet notamment d’éviter les fuites mémoire qui pourraient survenir avec des pointeurs nus :</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">Animal</span><span class="o">*></span> <span class="n">animaux</span><span class="p">;</span>
<span class="n">animaux</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="k">new</span> <span class="n">Chien</span><span class="p">());</span>
<span class="n">animaux</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="k">new</span> <span class="n">Chat</span><span class="p">());</span>
</pre></div>
</td></tr></table></div>
<p>Ici, à la moindre exception, les pointeurs sont détruits mais les resources reste en vie : fuite mémoire.</p>
<div class="footnote">
<hr>
<ol>
<li id="fn-1">
<p>Même si depuis Java 8 il y a les "implémentations par défaut". <a class="footnote-backref" href="#fnref-1" title="Retourner au texte de la note 1">↩</a></p>
</li>
</ol>
</div>[C++] Héritage et vectors, message #1556612017-07-08T15:50:00+02:00minirop/@minirophttps://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155661<p>une classe "abstraite", on ne peut juste pas l’instancier, mais ça reste une classe "normale" comme les autres (elle peut hériter d’une autre classe, elle peut avoir des variables et fonctions membres, des constructeurs et tout, etc.</p>[C++] Héritage et vectors, message #1556522017-07-08T15:18:14+02:00p4radox/@p4radoxhttps://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155652<p>Je comprends mieux, en effet.</p>
<p>Par contre, est-ce que dans une classe abstraite on peux mettre des membres que la classe concrète peut ré-utiliser ou alors une classe abstraite n’est qu’un concept abstrait justement et toute l’implémentation se fait dans les classes concrètes ?</p>
<p>En revanche, <code>unique_ptr</code> je n’ai jamais vu ce truc, qu’est-ce que c’est ?</p>
<p>Une classe abstraite n’a pas de constructeur logiquement alors, si ?</p>[C++] Héritage et vectors, message #1556492017-07-08T14:17:41+02:00Olybri/@Olybrihttps://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155649<figure>
<blockquote>
<p>Si j’ai bien compris, on ne peut pas instancier un objet d’une type abstrait, il faut donc instancier directement un objet de la classe dérivée.</p>
</blockquote>
<figcaption><a href="https://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155633">p4radox</a></figcaption>
</figure>
<p>Exactement.</p>
<figure>
<blockquote>
<p>D’accord, mais alors du coup est-ce que je dois ré-implenter toute la classe mère dans la classe fille ? (Les mêmes variables membres, fonctions, etc…) ou juste implanter celles de la classe fille ?</p>
</blockquote>
<figcaption><a href="https://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155633">p4radox</a></figcaption>
</figure>
<p>Dans ta classe fille, il suffit de définir les fonctions abstraites (virtuelles pures) de ta classe mère.</p>
<p>Voici un exemple d’implémentation tout simple :</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="c1">// notre classe abstraite qu'on ne peut pas instancier</span>
<span class="k">struct</span> <span class="n">Animal</span>
<span class="p">{</span>
<span class="c1">// et notre fonction abstraite</span>
<span class="k">virtual</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">cri</span><span class="p">()</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">};</span>
<span class="c1">// une classe concrète, fille de notre classe abstraite</span>
<span class="k">struct</span> <span class="nl">Chien</span> <span class="p">:</span> <span class="n">Animal</span>
<span class="p">{</span>
<span class="c1">// on redéfinit (override) la fonction abstraite</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">cri</span><span class="p">()</span> <span class="k">override</span>
<span class="p">{</span>
<span class="k">return</span> <span class="s">"ouaf"</span><span class="p">;</span>
<span class="p">};</span>
<span class="p">};</span>
<span class="c1">// une autre classe fille</span>
<span class="k">struct</span> <span class="nl">Chat</span> <span class="p">:</span> <span class="n">Animal</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">cri</span><span class="p">()</span> <span class="k">override</span>
<span class="p">{</span>
<span class="k">return</span> <span class="s">"miaou"</span><span class="p">;</span>
<span class="p">};</span>
<span class="p">};</span>
</pre></div>
</td></tr></table></div>
<p>Avec un exemple d’utilisation :</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3
4
5
6
7
8
9</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="c1">// on crée une liste d'animaux abstraits</span>
<span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">unique_ptr</span><span class="o"><</span><span class="n">Animal</span><span class="o">>></span> <span class="n">animaux</span><span class="p">;</span>
<span class="c1">// on y ajoute des animaux concrets</span>
<span class="n">animaux</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">make_unique</span><span class="o"><</span><span class="n">Chien</span><span class="o">></span><span class="p">());</span>
<span class="n">animaux</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">make_unique</span><span class="o"><</span><span class="n">Chat</span><span class="o">></span><span class="p">());</span>
<span class="c1">// on affiche leur cri</span>
<span class="k">for</span><span class="p">(</span><span class="k">auto</span> <span class="o">&</span> <span class="nl">animal</span> <span class="p">:</span> <span class="n">animaux</span><span class="p">)</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">animal</span><span class="o">-></span><span class="n">cri</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
</pre></div>
</td></tr></table></div>
<p>Ce qui va afficher :</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2</pre></div></td><td class="code"><div class="codehilite"><pre><span></span>ouaf
miaou
</pre></div>
</td></tr></table></div>[C++] Héritage et vectors, message #1556332017-07-08T10:57:47+02:00p4radox/@p4radoxhttps://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155633<p>Bonjour et merci pour ta réponse qui m’a permis de comprendre un peu plus de choses.
Du coup j’ai utilisé une fonction virtuelle pure.
Mais j’ai une autre question :</p>
<p>Ma classe mère du coup est devenue une classe abstraite (Encore un truc nouveau là <img alt=":pirate:" src="/static/smileys/pirate.png"> )
Si j’ai bien compris, on ne peut pas instancier un objet d’une type abstrait, il faut donc instancier directement un objet de la classe dérivée.
D’accord, mais alors du coup est-ce que je dois ré-implenter toute la classe mère dans la classe fille ? (Les mêmes variables membres, fonctions, etc…) ou juste implanter celles de la classe fille ?
J’ai un doute mais j’ai l’impression que c’est la première solution si je regarde dans le Primer.</p>
<hr>
<p>EDIT : En re-lisant ton post, je viens de saisir comment fonctionne le polymorphisme et ce par rapport à un héritage simple. Seulement c’est que je n’arrive pas à implémenter le tout.</p>
<hr>
<p>EDIT 2 : Bon j’ai re-lu le Primer et un peu avancé et j’ai compris d’autres choses, du coup j’ai modifié mon code.
(J’aime pas le travail mâché mais à ce qu’il parait on peut jamais s’en sortir tout le temps tout seul dans la vie sauf si on s’apelle Mike Horn lol)</p>
<p>Ce que j’ai fait, j’ai supprimé tous mes getters qui finalement foutent plus le boxon qu’autre chose et j’ai implanté dans la classe mère une fonction membre virtuelle <code>void .afficher()</code> qui claque à l’écran les membres de la classe mère et ensuite dans chaque classe fille on a également la même fonction membre sauf que dans l’implémentation, celles des classes filles font appel à la fonction membre de la classe mère avec son scope et ensuite j’affiche le membre de la classe fille.</p>
<p>Aucun problème de compilation, je crois avoir compris que le polymorphisme fonctionne comme ça <img alt=":D" src="/static/smileys/heureux.png"> …
Sauf que dans mon vector j’ai toujours des objets mères car quand le programme déroule, il m’affiche bien les membres de la classe mère mais pas celui de la fille donc j’en conclu que même en faisant un <code>.push_back()</code> d’objets filles, le vector se torche avec.</p>
<p>Cependant j’ai lu dans le primer que pour avoir plusieurs types d’objets dans une collection (Array, Vector), il fallait en fait déclarer un vector de pointeur d’objets mère.
D’accord, très bien mais moi je souhaite utiliser les références à la place et ne pas du coup utiliser les pointeurs ainsi que l’allocation dynamique <code>new</code> et <code>delete</code> (Préférer les capsules RAII mais ça je ne sais pas faire encore).</p>
<p>Une idée ?</p>[C++] Héritage et vectors, message #1556132017-07-08T01:49:30+02:00Praetonus/@Praetonushttps://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155613<blockquote>
<p>Le mot clé virtual permet au compilateur de savoir quelle fonction membre utiliser, celle de la classe mère ou celle de la classe fille selon de quel type d’objet il s’agit.</p>
</blockquote>
<p>En effet, mais il faut en plus que les instances de la classe fille soient accédées à travers une référence (ou un pointeur) sur la classe mère. Sinon, on a du <em>slicing</em> et ça ne marche pas (la fonction de la classe mère est appelée).</p>
<blockquote>
<p>Dès qu’il y a héritage, la classe mère doit avoir son destructeur marqué virtual car sinon au moment de la destruction de l’objet, celle des classes filles ne se feront pas (Donc pas de destructeur dans les classes filles)</p>
</blockquote>
<p>C’est l’idée, mais seulement dans les hiérarchies polymorphiques (où des instances de classes filles peuvent être accédées via des références sur la classe mère). Il y a une règle quelque part qui dit qu’un destructeur doit être public et virtuel dans une hiérarchie polymorphique, et protégé et non-virtuel dans une hiérarchie non-polymorphique. Si ça n’est pas clair, tu peux t’en tenir à héritage => destructeur virtuel.</p>
<p>Pour le problème que tu as, ce n’est pas possible comme ça. Le principe derrière le polymorphisme est celui de substituabilité : remplacer une instance d’une classe mère par une instance d’une classe fille ne doit pas casser le programme (la classe fille ne peut pas renforcer les préconditions ou affaiblir les postconditions). Le corollaire, c’est que les instances des différentes classes filles doivent également être substituables entre elles, ce qui fait qu’on doit s’en tenir à l’interface de la classe mère (car rien ne dit au compilateur que toutes les classes filles de <code>Mere</code> implémentent une fonction <code>Fille</code> (enfin si, il peut s’en rendre compte, mais ça ne serait pas confortable d’en faire une règle du langage, car des erreurs pourraient apparaître sur une interface selon la disposition d’une autre interface)).</p>
<p>La solution est donc d’ajouter la fonction <code>Fille</code> à l’interface de <code>Mere</code>, soit en fournissant une implémentation, soit en en faisant une fonction virtuelle pure.</p>
<p>Et du coup pour</p>
<blockquote>
<p>Est-ce que la fonction membre de la classe fille doit aussi être dans la classe mère ? (En utilisant virtual).</p>
</blockquote>
<p>Oui, si tu as besoin de l’utiliser polymorphiquement depuis une référence sur la classe mère. Sinon, ça n’est pas obligé.</p>[C++] Héritage et vectors, message #1556122017-07-08T01:13:48+02:00p4radox/@p4radoxhttps://zestedesavoir.com/forums/sujet/8922/c-heritage-et-vectors/?page=1#p155612<p>De ce que j’ai compris :</p>
<ul>
<li>Le mot clé <code>virtual</code> permet au compilateur de savoir quelle fonction membre utiliser, celle de la classe mère ou celle de la classe fille selon de quel type d’objet il s’agit.</li>
<li>Dès qu’il y a héritage, la classe mère doit avoir son destructeur marqué <code>virtual</code> car sinon au moment de la destruction de l’objet, celle des classes filles ne se feront pas (Donc pas de destructeur dans les classes filles)</li>
<li>Du coup, effectivement, le polymorphisme dont j’ai besoin là, c’est le dynamique car dans le constructeur des classes filles, je passe par référence un objet de type classe mère et que les deux fonctions membres (Qui sont des getters inlinés) sont marquées <code>virtual</code> car je les utilisent aussi dans les classes filles</li>
</ul>
<p>En revanche, ce que je ne comprends pas, c’est pourquoi une fonction membre dans la classe fille qui n’existe pas dans la classe mère ne peut pas être utilisée, (Enfin je pense que je n’arrive pas à implémenter ça pour le coup) et que du coup même en passant par référence un objet de la classe mère à la classe fille pour la construction de cette dernière, le programme "voit" mes objets filles comme des objets mères.</p>
<p>La fonction membre en question est aussi un getter inliné qui retourne la valeur de la variable membre de la classe fille mais rien de tout ça n’est existant dans la classe mère.</p>
<p>J’espère que c’est ce que tu attendais, camarade <img alt=":euh:" src="/static/smileys/unsure.gif"> .</p>