Je suis néophyte en C++ mais très intéressé par ce monde de développement !
Je me pose la question suivante. Par exemple, j'ai une classe Division contenant divers attributs comme la puissance, la vie... Cette classe permet d'utiliser les attributs et les membres pour d'autres classes comme Blindes, Soldats, Artillerie,... Prenons par exemple la classe Blindes qui utilise donc les attributs de la classe Division mais personnalisés admettons que la puissance est 10, la vie 5. Comment puis-je coder cette situation ?
Pour ça tu as l'héritage. Faire hériter une classe d'une autre te permet de donner à ta classe fille tous les attributs et toutes les méthodes appartenant à ta classe mère.
Dans ton cas, tes classes Blindes, Soldat, Artillerie... héritent toutes de Division. Elles auront donc toutes un attribut puissance, un attribut vie... à toi d'ensuite initialiser ces attributs aux valeurs souhaité, directement dans ton fichier d'en-tête par exemple.
Cela donnerait quelque chose dans ce goût-là :
class Blindes : public Division {
public :
Blindes();
~Blindes();
type methode1();
private :
type m_blindes1;
};
En ajoutant public : Division, tu fais hérité ta classe Blindes de Division, et tous les attributs de ta classe Division seront aussi utilisables pour Blindes, sans avoir besoin de les déclarer.
Faire hériter Blindé de Division ? Ce sont deux choses carrément différente. Je dirais plutôt qu'une division possède des Blindés. Les blindés devraient être plutôt des attributs de Division.
Faire hériter Blindé de Division ? Ce sont deux choses carrément différente. Je dirais plutôt qu'une division possède des Blindés. Les blindés devraient être plutôt des attributs de Division.
Oui, on écrirait plutôt:
class Blindes {
... ...
};
class Division {
... ...
void ajout_d_un_blinde() {
m_blindes.emplace_back(); // un Blindé de plus dans le Division
}
private:
std::vector<Blindes> m_blindes;
};
Sergentdeveloppeur a écrit : "Prenons par exemple la classe Blindes qui utilise donc les attributs de la classe Division mais personnalisés admettons que la puissance est 10, la vie 5."
Je comprends ici que Blindes hérite de Division. Dans les faits, je serais tenté de dire comme toi qu'une Division contient entre autre des Blindes, mais je crois que ce qu'il veut faire c'est une division de Blindes, une division d'Artillerie, etc...
Mais si j'ai mal compris, alors effectivement il faudrait une classe pour chaque, plus question d'héritage, et faires des Blindes, Artillerie, etc des attributs de la classe Division.
Pour rappel, l'héritage n'est en aucun cas une mécanique de factorisation de code!!!
Astuce pour éviter d'y avoir recours pour tout et n'importe quoi, pose toi les bonnes questions:
- Si un objet A est un objet B, on peut avoir recours à l'héritage. Exemple: Une voiture est un vehicule (voiture peut hériter de vehicule). Ce qui se traduit en code:
class vehicule
{
};
class voiture: public vehicule
{
};
- Si un objet A a des (ou contient des) objets B, alors on a recours à une composition. Exemple: Une voiture a 4 roues. Ce qui se traduit en code:
class roue
{
};
class voiture
{
private:
std::array<roue, 4> roues;
}
Pour ça tu as l'héritage. Faire hériter une classe d'une autre te permet de donner à ta classe fille tous les attributs et toutes les méthodes appartenant à ta classe mère.
HéHé ... non...
On peut dire que la puissance totale ainsi que la vie totale d'une division est la somme de la puissance (et de la vie) des blindés qui la composent.
On peut estimer que "n'importe quel blindé" composant une division peut profiter de la puissance et de la vie "globales" de la division (qu'il suffit d'un appel au QG de la division pour que tous les blindés de la division se mettent en route pour lui venir en aide).
Mais les relations qui existent entre les blindés et la division sont des relation d'appartenance (un blindé appartient à une division) et d'utilisation (la division utilise un blindé qui peut en retour utiliser l'ensemble de la division ).
Ce qu'il faut comprendre, c'est que la relation d'héritage est la relation la plus forte qui puisse exister entre deux classes et qu'elle implique la substituabilité.
C'est donc la relation qu'il faudra utiliser, si pas "le moins souvent", en tous les cas "avec le plus de précautions possibles".
Et pour pouvoir l'utiliser avec toutes les précautions, il faut garder en tête que la relation d'héritage implique que si un type B hérite du type A, c'est que l'on doit pouvoir transmettre n'importe quel objet de type B à n'importe quelle fonctionnalité s'attendant à manipuler un objet de type A.
Ca marche avec un type "voiture" (ou "camion", ou "moto" ou "planche à voile", même, si tu veux) qui hérite de "véhicule", car voiture, camion, moto et planche à voile fournissent effectivement tous les services que l'on est en droit d'attendre de la part d'un "véhicule" (sans autre précision).
Mais cela ne fonctionne absolument pas entre "division" et "blindé":
Les services fournis par un "blindé" seraient en effet du genre de
déplaces-toi à tel endroit
tir dans telle direction avec telle inclinaison
écrase tel groupe de personnes
Alors que les services fournis par une "division" seraient du genre de
envoyer tel nombre de blindés vers tel endroit
ordonner au blindés de tirer dans telle direction avec telle inclinaison
ordonner la retraite
...
Tu vois la différence ?
Ce qui se conçoit bien s'énonce clairement. Et les mots pour le dire viennent aisément.Mon nouveau livre : Coder efficacement - Bonnes pratiques et erreurs à éviter (en C++)Avant de faire ce que tu ne pourras défaire, penses à tout ce que tu ne pourras plus faire une fois que tu l'auras fait
Je n'ai pas pu continuer mon programme la semaine dernière et mon sujet a continué et c'est tant mieux du coup
Je vois la classe Division comme une classe ayant des attributs qui me serviront pour toutes les autres classes c'est à dire Blindés, Soldats, Artillerie, ... A vrai dire je suis bloqué. Je ne sais pas comment utiliser l'héritage même si j'ai compris le principe.
Je vous mets ce que j'ai déjà codé. J'ai bien conscience qu'il y a sûrement des fautes et tout mais justement je veux progresser et comprendre. J'imagine qu'il manque un constructeur pour la classe Division me permettant de m'en servir pour la classe Blindés. J'ai justement écris dans ma classe Blindés comment je verrai l'utilisation.
Je vous remercie pour votre aide précieuse
Division.h
class Division
{
public:
Division(); //constructeur
bool estDetruit() const; //lorsque vie=0 -> destruction donc impossible d'utiliser l'unité
void interface() const; //permet de visualiser simplement l'interface des unités notamment la vie
protected:
int m_puissance; //degats
int m_porteeX; //portee d'un tir sur axe X
int m_porteeY; //portee d'un tir sur axe Y
int m_vie; //vie
int m_deplacementX; //déplacement possible sur axe X
int m_deplacementY; //déplacement possible sur axe y
std::string m_nom; // nom
};
Division.cpp
#include <iostream>
#include <string>
#include "division.h"
Division::Division()//constructeur
{
}
bool Division::estDetruit() const //lorsque vie = 0 -> destruction -> déplacement impossible
{
if (m_vie<0)
{
return true; //la division est détruite
}
else
{
return false; //la division est encore en état de combattre
}
}
void Division::interface () const
{
if (estDetruit()==true)
{
std::cout<<"Vehicule detruit"<<std::endl;
}
else
{
std::cout <<"Vie: "<<m_vie<<std::endl;
}
}
Blindes.h
#ifndef BLINDES_H_INCLUDED
#define BLINDES_H_INCLUDED
#include <iostream>
#include <string>
#include "division.h"
class Blindes: public Division //la classe Blindes hérite de la classe Division
{
public:
Blindes(); //constructeur
};
#endif // BLINDES_H_INCLUDED
TU NE PEUX PAS FAIRE HERITER BLINDE DE DIVISION!!!
C'est un erreur de conception, qui va te poser bien plus de problèmes que la "non solution" que cella te permettra d'obtenir à court termes.
Si tu veux avoir une division et des blindés, c'est une relation de composition qui doit relier les deux:
class Division;
class Blinde{
public:
int puissance() const{
return m_puissance;
}
int vie() const{
return m_vie;
}
Position const & positin() const{
return m_position;
}
void attaquer(Position const &);
void seDeplacer(position const & vers);
/* .. */
private:
int m_puissance;
int m_vie;
Positin m_position;
Portee m_portee;
Division * m_division; // pour "faire le lien" entre le blinde et la division
// à laquelle il appartient
};
class Division(){
public:
void ajouteBlinde(/* paramètres */){
/* création du blindé,
* ajout du blindé à la liste,
* ajout des caractéristiques du blindé
* aux valeurs totales utilisées pour désigner
* la division
*/
}
Blinde const & get(/* identifiant) const{
/* recherche du blindé selon le critère
* renvoie le blindé s'il existe
*/
}
int puissanceTotale() const{
/* renvoie la puissance totale de l'ensemble des
* blindés de la division
*/
return m_puissanceTotale;
}
int vieTotale() const{
/* renvoie la vie totale de l'ensemble des
* blindés de la division
*/
}
private:
std::vector<Blinde> m_blindes; // tous les blindes
// de la division
int m_puissanceTotale; // pour ne pas devoir la recalculer
// à chaque fois qu'on en veut,
// on la met à jour "en direct"
int m_vieTotale; // idem
};
Ce qui se conçoit bien s'énonce clairement. Et les mots pour le dire viennent aisément.Mon nouveau livre : Coder efficacement - Bonnes pratiques et erreurs à éviter (en C++)Avant de faire ce que tu ne pourras défaire, penses à tout ce que tu ne pourras plus faire une fois que tu l'auras fait
Je pense que c'est juste un problème de nommage, ces "Blindes", c'est juste une Division blindés (DB), "Soldats" c'est une Division d'Infanterie et "Artillerie" une "Division d'Artillerie" (je sais que d'un point de vue militaire, cela n'a jamais eu de réalité mais il doit faire vraisemblablement un jeu "simpliste" et pas un wargame poussé).
Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.
Oui effectivement, bacelar a raison. Il n'est pas question de faire un wargame poussé (je n'ai pas du tout le niveau pour cela) et effectivement je le vois comme une division ayant des paramètres permettant ensuite de les utiliser et d'initialiser les attributs pour les blindés, l'artillerie, etc...
C'est pour cette raison que j'ai mis le constructeur dans le fichier Blindes.cpp de cette manière pour vous expliquer mon raisonnement
Oui effectivement, bacelar a raison. Il n'est pas question de faire un wargame poussé (je n'ai pas du tout le niveau pour cela) et effectivement je le vois comme une division ayant des paramètres permettant ensuite de les utiliser et d'initialiser les attributs pour les blindés, l'artillerie, etc...
C'est pour cette raison que j'ai mis le constructeur dans le fichier Blindes.cpp de cette manière pour vous expliquer mon raisonnement
Dans ce cas, il faut vraiment veiller à utiliser des noms qui désignent clairement et sans ambiguïté ce qu'ils sont censés représenter.
Si la "plus petite unité indivisible" de ton jeu est une division (blindée, d'infanterie, d'artillerie ou que sais-je), il faut vraiment veiller à ce que les termes utiliser transmettent cette information de manière évidente.
Non seulement pour toi, car tu peux laisser ton projet sur le coté pendant suffisamment longtemps que pour en oublier une grosse partie, mais aussi pour toute autre personne qui serait amenée, pour une raison ou une autre, à lire ton code.
Ma réaction précédente le démontre à loisir: il semblait clair dans ton esprit que "blindé" représentait ... une division blindée, alors que, j'avais interprété ce terme en fonction de sa signification réelle, à savoir comme un "un véhicule motorisé équipé d'un blindage".
Nous utilisions donc le même terme de manière radicalement différente. Et c'est typiquement le genre de chose qui occasionne énormément de problème.
Ton but, lorsque tu choisi l'identifiant associé à une notion (qu'il s'agisse d'un type de donnée, d'une donnée ou d'une fonction) doit systématiquement tendre vers le fait de ne laisser aucune place pour (la mauvaise) l'interprétation de l'usage auquel cette chose est destinée
Comme l'écrit si bien Christopher Paolini
Eragon, 2002
Blisingr signifie le feu. C'est le feu
Connait le mot, et tu maitrise la chose
Ce qui se conçoit bien s'énonce clairement. Et les mots pour le dire viennent aisément.Mon nouveau livre : Coder efficacement - Bonnes pratiques et erreurs à éviter (en C++)Avant de faire ce que tu ne pourras défaire, penses à tout ce que tu ne pourras plus faire une fois que tu l'auras fait
Je comprends tout à fait par le fait que mes dénominations portent à confusion ici. Cela montre un mauvais choix des termes.
Toutefois, pour revenir à la source de mon problème, comment puis-je coder ma volonté à définir les attributs simplement d'une classe grâce à une classe "principale" en reprenant mon exemple plus haut où j'explicite mon code ?
Merci bien
- Edité par Sergentdeveloppeur 12 avril 2022 à 19:42:30
Tu dois commencer par abandonner cette idée saugrenue qu'une classe n'est que la somme de ses attributs.
Cela te permettra de comprendre qu'une classe est d'abord et avant tout un fournisseur de services, qui peuvent prendre deux formes:
Soit, le service fournit la capacité de répondre à une question que l'on se pose au sujet de la classe
Soit, le service fournit la capacité de réagir à un ordre bien particulier, d'exécuter cet ordre bien particulier
Les bénéfices obtenus à partir des services fournis par une classe vont donc bien au delà de la simple addition de tous ses attributs, qui ne sont en réalité que des "détails d'implémentations" permettant à la classe de fournir les services que l'on attend de sa part.
Le role "interne" de la classe est alors de s'assurer que la valeur associée à chacun de ses attributs respectent les conditions d'utilisations imposées par la classe elle-même
Par contre, une fois que tu sera conscient de cela, il te deviendra "évident" que, les attributs n'étant là que pour permettre à la classe de rendre les services que l'on attend de sa part, l'utilisation de l'héritage pour "réutiliser des attribut" est une pure absurdité, que si on décide d'utiliser l'héritage, c'est pour profiter des services rendus par la classe.
Si l'on part de la notion de "division" comme étant un "groupe armé" sans autre précision (car on peut avoir des divisions d'infanterie, d'artillerie, de blindés, aéroportées ou navales), il faudra donc te poser la question de quels sont les services que l'on peut espérer obtenir de "n'importe quelle division" (sans autre précision).
En gros, les questions que l'on voudrait pouvoir lui poser seraient sans doute proche de
où te trouves-tu?
quel est ton status? (au repos / attaquée /en activité / ... )
quel est ton état? (en pourcentage d'effectif à un instant T)
quel est l'état de ton ravitaillement ("j'ai de quoi voir venir" / "j'ai utilisé beaucoup de mes ressources" / "je n'ai presque plus rien")
Quant aux ordres que l'on voudrait pouvoir lui donner (quel que soit le type réel de la division), ce serait du genre de
déplaces toi vers (telle position)
vient en aide à (telle division)
abandonne ta position
lance une attaque sur (telle position)
va te ravitailler à (telle position)
Tu constatera directement que le simple fait de répondre à ces questions et de donner la possibilité à ta notion de division d'obéir aux ordres qui lui sont données te fera mettre en place "un certain nombre d'attributs" pour lesquelles elle pourra déterminer la validité des valeurs qui y sont associées.
A partir de là, tu pourras te dire que la notion de position ou que la notion de status est vraiment commune à l'ensemble des différentes divisions possibles. que c'est donc un comportement qui ne nécessite absolument pas d'être redéfini par la suite (comprends: qui n'a aucune raison d'être déclaré comme virtuel en C++).
Pour ce qui est des notions d'état et de ravitaillement, il est sans doute encore possible de discuter: soit tu fais en sorte que les attributs utilisés pour répondre à ces questions soient commun à l'ensemble des divisions, et tu peux "assez facilement" un comportement commun (comme tu l'as fait pour les notions de status et de position), soit tu considère que la réponse à apporter à ces questions mérite d'être adaptée en fonction du type réel de division (car une division d'infanterie calcule peut-être la réponse différemment d'une division blindée), et tu peux donc décider de déclarer ces fonctions virtuelles.
Sans oublier, bien sur, la possibilité de poser des questions plus spécifiques en fonction du type de division auquel on a affaire: tu peux tout à fait poser une question à une division d'infanterie qui n'a réellement de sens que parce que tu la pose -- justement -- à une division d'infanterie, mais qui n'aurais absolument aucun sens si tu venait à la poser à une division aéroportée
Et, bien sur, il en va de même pour les ordres que tu auras prévu de pouvoir donner à "n'importe quelle division":
Certaines d'entre elles provoqueront une réaction identique, quel que soit le type réel de la division envisagée
d'autres nécessiteront une adaptation du comportement (essaye, juste pour rire, de faire se déplacer une division de navires au centre de l'ile )
et l'on peut même ajouter quelques ordre spécifiques en fonction du type réel de la division envisagée
Une fois que tu seras arrivé à ce point, tu pourras te dire que tu commence effectivement à avoir quelque chose de "raisonnable" et qui commence à tenir la route.
Car, une fois que tu auras définis les différents types de division dont tu as besoin (en gardant d'ailleurs la possibilité d'en créer d'autres si nécessaire), tu pourras envisager de créer des instances de ces différentes divisions et, comme toutes tes classes hériteront (de manière directe ou indirecte) de la classe de base "division", tu pourras même mettre "toutes les divisions" (quel que soit leur type réel) "dans un même panier", en considérant qu'il s'agit "de divisions" sans autre précision, et tu seras à tout le moins en mesure de leur poser les questions et de leur donner les ordres auxquelles tu t'attend à ce que la notion de division (sans autre précision) puisse réagir
NOTA: il va de soi que les services rendus par la notion de division dans cette réponse sont purement imaginaires et ne prétendent absolument pas correspondre à ce dont tu as effectivement besoin.
Ils ne sont donnés que "à titre d'exemples", afin de te permettre de comprendre l'idée que tu dois essayer de suivre
- Edité par koala01 11 avril 2022 à 20:45:58
Ce qui se conçoit bien s'énonce clairement. Et les mots pour le dire viennent aisément.Mon nouveau livre : Coder efficacement - Bonnes pratiques et erreurs à éviter (en C++)Avant de faire ce que tu ne pourras défaire, penses à tout ce que tu ne pourras plus faire une fois que tu l'auras fait
Ton terme Blindés semble nous presque tous enduits d'erreur sauf Aëgis.
Sergentdeveloppeur a écrit:
Prenons par exemple la classe Blindes qui utilise donc les attributs de la classe Division mais personnalisés admettons que la puissance est 10, la vie 5. Comment puis-je coder cette situation ?
N'est pas la bonne manière de construire ta DivisionBlindes. Même si tes champs sont protected ils ne sont pas pour autant des champs de DivisionBlindes, tu ne peux pas les créer comme cela car le constructeur de Division est exécuté en premier et c'est à lui d'initialiser ses membres. Tu peux reprendre le constructeur de Division comme cela:
class Division
{
public:
Division(std::string_view nom, int puissance, int porteeX, int porteeY, int vie, int deplacX, int deplacY)
: m_puissance{puissance}, m_porteeX{porteeX}, m_porteeY{porteeY}, m_vie{vie},
m_deplacementX{deplacX}, m_deplacementY{deplacY}, m_nom(nom) {
}
bool estDetruit() const; //lorsque vie=0 -> destruction donc impossible d'utiliser l'unité
void interface() const; //permet de visualiser simplement l'interface des unités notamment la vie
virtual ~Division() = default; // Le destructeur doit être à minima virtual ou protected pour l'héritage
// ... ... autres fonctions nécessaires (public ou protected ou private) ... ...
// ... par exemple, si la manière de se déplacer dépend du type de Division
virtual bool SeDeplacerEn(int x, int y);
private:
int m_puissance; //degats
int m_porteeX; //portee d'un tir sur axe X
int m_porteeY; //portee d'un tir sur axe Y
int m_vie; //vie
int m_deplacementX; //déplacement possible sur axe X
int m_deplacementY; //déplacement possible sur axe y
std::string m_nom; // nom
};
Et maintenant, tu peux créer ta DivisionBlindes:
DivisionBlindes::DivisionBlindes(std::string_view nom)
: Division{nom, 50, 2, 2, 100, 1, 1} { // on passe à Division tout ce dont elle à besoin pour s'initialiser
}
Merci koala01 pour cette réponse très complète. C'est très intéressant !! Je n'ai pas le niveau pour encore créer un tel programme et une telle prise de considération mais déjà ton message permet d'avoir une bonne vision, une bonne pensée et de une méthodologie
Je te remercie aussi Dalfab c'est très clair :)
- Edité par Sergentdeveloppeur 12 avril 2022 à 19:41:48
Utiliser une classe dans une autre classe
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
En recherche d'emploi.
En recherche d'emploi.