Comment faire le fichier cpp de guerrier ? //héritage c++

**vincent13990** · 04/02/2021, 17h44

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
/*
 * Personnage.h
 *
 *  Created on: 11 déc. 2020
 *      Author: vincent
 */
 
#ifndef PERSONNAGE_H_
#define PERSONNAGE_H_
#include <iostream>
#include <string>
#include "Arme.h"
 
class Personnage
{
 
public:
	Personnage();
	Personnage(std::string monArme, int degatsArme);
	~Personnage();
	void recevoirDegats(int nbDegats);
	void attaquer(Personnage &cible);
	void boirePotionDeVie (int quantitePotion);
	void changerArme(std::string nomNouvelleArme, int degatsNouvelleArme);
	void coupDePoing (Personnage &cilble) const;
	bool estVivant() const;
	void afficherEtat() const;
private:
	int m_vie;
	int m_mana;
	Arme *m_arme; //pointeur
	std::string m_nom;
};
 
#endif /* PERSONNAGE_H_ */

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
/*
 * Personnage.cpp
 *
 *  Created on: 11 déc. 2020
 *      Author: vincent
 */
 
#include "Personnage.h"
 
using namespace std;
void Personnage::recevoirDegats(int nbDegats)
{
	m_vie -= nbDegats;
if (m_vie < 0)
	{
		m_vie = 0;
	}
}
int Arme::getDegats() const
{
	return m_degats;
}
 
void Personnage::attaquer(Personnage &cible)
{
	cible.recevoirDegats(m_arme->getDegats());
}
void Personnage::boirePotionDeVie (int quantitePotion)
{
	m_vie += quantitePotion;
	if (m_vie > 100)
	{
	m_vie = 100;
	}
}
void Personnage::changerArme(string nomNouvelleArme, int degatsNouvelleArme)
{
	m_arme->changer(nomNouvelleArme, degatsNouvelleArme);
	//pas dans le bouquin demander par le compilateur
	//m_nomArme = nomNouvelleArme;
	//m_degatsArme = degatsNouvelleArme;
}
bool Personnage::estVivant() const
{
	if (m_vie > 0)
		{
			return true;
		}
	else
		{
			return false;
		}
}
Personnage::Personnage() :m_vie(100),m_mana(100),m_arme(0)
{
	 m_arme = new Arme();
 
}
Personnage::Personnage(string nomArme, int degatsArme): m_vie(100), m_mana(100),m_arme(0)
{	//nomArme, degatsArme
	m_arme = new Arme(nomArme,degatsArme );
}
Personnage::Personnage () : m_vie (100), m_nom("jack"),m_mana(100),m_arme(0)
{
}
void Personnage::recevoirDegats(int degats)
{
	m_vie -= degats;
}
void Personnage::coupDePoing(Personnage &cible)const
{
	cible.recevoirDegats(10);
}
void Personnage::afficherEtat() const
{
   cout << "Vie : " << m_vie << endl;
    cout << "Mana : " << m_mana << endl;
    m_arme->afficher();
}
 
Personnage::~Personnage()
{
delete m_arme;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
/*
 * Arme.cpp
 *
 *  Created on: 11 déc. 2020
 *      Author: vincent
 */
 
#include "Arme.h"
using namespace std;
 
Arme::Arme() : m_nom ("Epée rouillée"),m_degats (10)
{
}
 
 
 
Arme::Arme(string nom, int degats) : m_nom (nom),m_degats (degats)
{
}
 
 
void Arme::changer(string nom, int degats)
{
	m_nom= nom;
	m_degats = degats;
}
void Arme::afficher()const
{
	cout<<" Arme : " << m_nom << "(Degats : "<< m_degats <<")"<< endl;
}
Arme::~Arme()
{
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
/*
 * Arme.h
 *
 *  Created on: 11 déc. 2020
 *      Author: vincent
 */
 
#ifndef ARME_H_
#define ARME_H_
#include <iostream>
#include <string>
class Arme {
 
public:
	Arme();
 
 
		~Arme();
		Arme(std::string nom, int degats);
		void changer(std::string nom, int degats);
		void afficher() const;
		int getDegats() const;
 
 
private :
	std::string m_nom;
	int m_degats;
 
};
 
#endif /* ARME_H_ */

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <iostream>
#include <string>
#include "Personnage.h"
 
using namespace std;
 
 
int main()
{
    // Création des personnages
    Personnage david, goliath("Epée aiguisée", 20);
 
    // Au combat !
    goliath.attaquer(david);
    david.boirePotionDeVie(20);
    goliath.attaquer(david);
    david.attaquer(goliath);
    goliath.changerArme("Double hache tranchante vénéneuse de la mort", 40);
    goliath.attaquer(david);
 
    // Temps mort ! Voyons voir la vie de chacun...
    cout << "David" << endl;
    david.afficherEtat();
    cout << endl << "Goliath" << endl;
    goliath.afficherEtat();
 
    return 0;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
 * Guerrier.h
 *
 *  Created on: 4 févr. 2021
 *      Author: vincent
 */
 
#ifndef GUERRIER_H_
#define GUERRIER_H_
#include <iostream>
#include <string>
#include "Personnage.h"
class Guerrier : public Personnage
{
public:
	void frapper () const ;
};
 
#endif /* GUERRIER_H_ */

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
/*
 * Guerrier.cpp
 *
 *  Created on: 4 févr. 2021
 *      Author: vincent
 */
 
#include "Guerrier.h"
 
 
Guerrier::Guerrier() public Personnage : m_vie (100), m_nom("jack"),m_mana(100),m_arme(0)
{
	m_arme = new Arme();
 
}
Guerrier::~Guerrier() {
	// TODO Auto-generated destructor stub
}

Comment implémenter le fichier Guerrier.cpp ? J' ai essayer plusieurs choses sans y arriver

**Bousk** · 04/02/2021, 18h02

Quelle est la question et le problème ?

Syntaxiquement, je vois pas comment quelconque difficulté peut se rencontrer.
Suffit de lire un cours pour la trouver et pas écrire cet ignoble Guerrier::Guerrier() public Personnage au hasard.
Architecturalement, est-ce que Guerrier devrait hériter de Personnage ? Bof.
Quelle est la différence entre Guerrier et Personnage ? Si c'est juste un tag, un enum dans Personnage qui décrit ce dont il s'agit est probablement mieux.

**vincent13990** · 19/03/2021, 15h56

Architecturalement, est-ce que Guerrier devrait hériter de Personnage ? oui c'est l'exercice

**koala01** · 19/03/2021, 16h54

Salut,

Envoyé par vincent13990

Architecturalement, est-ce que Guerrier devrait hériter de Personnage ? oui c'est l'exercice

C'est peut être le but de l'exercice, je n'en disconviens pas...

Par contre, il est totalement pourri cet exercice, car, à coté de la classe Guerrier, je suis près à parier que tu vas retrouver une classe Magicien, Archer ou Voleur et que, du coup, la fonction coupDePoing n'aura plus aucun sens pour les classes autres que Guerrier, ce qui va poser un problème conceptuel du au non respect du LSP ...

De plus, comme il n'y a aucune fonction virtuelle, c'est carrément le fait que Guerrier hérite de Personnage qui va poser problème, car il n'y a aucun polymorphisme d'inclusion à attendre dans cette situation, au point que l'on en vienne à se poser la question de savoir s'il est simplement cohérent d'envisager l'héritage

**vincent13990** · 20/03/2021, 09h23

merci j'apprends des tas de chose dans ton lien

**gabriel21** · 20/03/2021, 15h56

Cela ressemble au cours d'open classroom.
Personnellement, j'ai failli arrêté la programmation C++ à cause de lui.
Pour l'apprentissage de C++, j'utilise le très bon livre : Programmation principe et pratique en C++ de Bjarne Stroustrup chez Pearson. Il en existe une version mise à jour pour C++ 11.

Invité · 31/03/2021, 16h42

Envoyé par koala01

Salut,

C'est peut être le but de l'exercice, je n'en disconviens pas...

Par contre, il est totalement pourri cet exercice, car, à coté de la classe Guerrier, je suis près à parier que tu vas retrouver une classe Magicien, Archer ou Voleur et que, du coup, la fonction coupDePoing n'aura plus aucun sens pour les classes autres que Guerrier, ce qui va poser un problème conceptuel du au non respect du LSP ...

De plus, comme il n'y a aucune fonction virtuelle, c'est carrément le fait que Guerrier hérite de Personnage qui va poser problème, car il n'y a aucun polymorphisme d'inclusion à attendre dans cette situation, au point que l'on en vienne à se poser la question de savoir s'il est simplement cohérent d'envisager l'héritage

+1 ! Guerrier devrait du coup hérité de CaC (corps à corps, ayant coupDePoing en méthode), qui hérite lui de Personnage (n'ayant pas coupDePoing).

**koala01** · 02/04/2021, 13h26

Envoyé par fmartini

+1 ! Guerrier devrait du coup hérité de CaC (corps à corps, ayant coupDePoing en méthode), qui hérite lui de Personnage (n'ayant pas coupDePoing).

Ben non, même pas...

Enfin, oui: CorpsACorps (je préfère les noms explicite, car CaC, ca ne veut rien dire en particulier

) serait une notion qui mériterait effectivement d'exister.

Seulement, de mon point de vue, CorpsACorps est plutôt une technique de combat. Or, on ne peut pas décemment estimer qu'une technique de combat soit un personnage. Il ne serait donc pas cohérent de faire hériter CorpACorps de Personnage (s'il faut le faire hériter de quelque chose, ce serait sans doute de TechniqueDeCombat qui n'aurait aucun lien avec la classe Personnage

)

De même, on ne peut pas décemment estimer qu'un guerrier (ou même déjà qu'un personnage) soit une technique de combat quelconque (et plus précisément la technique CorpsACorps dans le cas présent).

Au mieux, on peut estimer qu'un personnage (sans précision) dispose d'une technique de combat (sans précision), et que, dans le cas du personnage qui serait un guerrier, cette technique serait le corps à corps.

Nous partirions donc plutôt sur une agrégation qu'un héritage pour représenter la technique de combat au niveau du personnage.

Seulement, nous risquons également d'avoir, par la suite, des personnages (a priori non joueur, et encore, ca reste à démontrer) comme les marchands qui n'ont aucun besoin de disposer d'une technique de combat. On ne peut donc pas partir du principe que n'importe quel personnage doive exposer une fonction membre attaque(Personnage &).

Si l'on voulait faire les choses de manière "correcte" (qui respecte les règles), même si ce n'est pas forcément pratique à utiliser, nous devrions en réalité avoir plusieurs "aspect" totalement séparés les un des autres (mais globalement interdépendants) comme:

la notion de personnage, qui représente les caractéristiques "physiques" (sexe, taille, long mince ou gros trapu, position, ...) et qui expose les possibilités offertes par une (ou plusieurs) interfaces
technicien: qui est capable de manipuler une technique particulière (le combat, le commerce, les soins, ...) qui donne accès à
une technique particulière (combat, commerce, soins, ...)
Et bien sur, nous pourrions encore complexifier les choses au niveau des techniques disponibles

et encore, je ne parle pas des autres spécialisations qui pourraient apparaitre, comme le fait qu'un personnage peut se spécialiser en "personnage joueur" (manipulé par un joueur) et "personnage non joueur" (manipulé par un système "d'intelligence artificielle")

Si bien que nous pourrions déjà nous en sortir avec un ensemble de techniques, sous une forme qui serait proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
class TechniqueSoin{
public:
    void soigner(Personnage & cible){
        soigner(cible, seletionnerSoinPersonne());
    }
    void soigner(Zone & cible){
        soigner(cible, seletionnerSoinZone());
    }
private:
    SoinPersonne const & selectionnerSoinPersonne(){
        /* il faut choisir le soin qui sera utilisé */
    }
    SoinZone const & selectionnerSoinZone(){
        /* il faut choisir le soin qui sera utilisé */
    }
    void soigner(Personnage & cible, SoinPersonne const & soin){
       /* appliquer le soin à la cible */
   }
    void soigner(Zone & cible, SoinZone const & soin){
       /* appliquer le soin à la cible */
   }
    std::list<std::reference_wrapper<SoinPersonne>> & listeSoinsPersonnes;
    std::list<std::reference_wrapper<SoinZone>> & listeSoinsZones;
 
};
class TechniqueDeSorts{
public:
 
    void utiliserSort(Personnage & cible){
        utiliserSort(cible, seletionnerSortPersonne());
    }
    void utiliserSort(Zone & cible){
        utiliserSort(cible, seletionnerSortZone());
    }
private:
    SoinPersonne const & selectionnerSortPersonne(){
        /* il faut choisir le sort qui sera utilisé */
    }
    SoinZone const & selectionnerSortZone(){
        /* il faut choisir le sort qui sera utilisé */
    }
    void utiliserSort(Personnage & cible, SoinPersonne const & soin){
       /* appliquer le sort à la cible */
   }
    void soigner(Zone & cible, SoinZone const & soin){
       /* appliquer le sort à la cible */
   }
    std::list<std::reference_wrapper<SortPersonne>> & listeSortsPersonnes;
    std::list<std::reference_wrapper<SortZone>> & listeSortsZones;
};
/* les techniques de combats nécessitent sans doute des spécialisation...
 * on pourrait donc travailler avec des template et des politiques
 */
struct TagCorpsACorps{};
struct TagDistance{};
struct tagMagie{};
 
template <typename TagTechnique
class TechniqueDeCombat{
public:
    void attaquer(Personnage & cible){
        attaquer(cible, selectionnerAttaquePersonne();
    }
    void attaquer(Zone & cible){
        attaquer(cible, selectionnerAttaquePersonne();
    }
private:
    AttaquePersonne<TagTechnique> const & selectionnerAttaquePersonne(){
        /* il faut choisir le sort qui sera utilisé */
    }
    AttaqueZone<TagTechnique> const & selectionnerAttaqueZone(){
        /* il faut choisir le sort qui sera utilisé */
    }
    void attaquer(Personnage & cible, AttaquePersonne<TagTechnique> const & attaque){
       /* appliquer l'attaque à la cible */
   }
    void attaquer(Zone & cible, AttaqueZone<TagTechnique> const & soin){
       /* appliquer l'attaque à la cible */
   }
    std::list<std::reference_wrapper<AttaquePersonne<TagTechnique>>> & listeSortsPersonnes;
    std::list<std::reference_wrapper<AttaqueZone<TagTechnique>>> & listeSortsZones;
};
/* et, par facilité, on peut créer des alias de type */
using TechniqueCorpsACorps = TechniqueDeCombat<tagCorpACorps>;
using TechniqueDistance= TechniqueDeCombat<tagDistance>;
using TechniqueMagique = TechniqueDeCombat<tagMagie>;

Mais ces classes, il est important de se rappeler qu'elles décrivent les techniques qui sont susceptibles d'être utilisée par les différents personnage.

On ne peut donc pas faire hériter un personnage particulier d'une technique particulière, pour la simple et bonne raison qu'un personnage n'est pas une technique: un personnage est le dépositaire d'une technique donnée.

En allant au plus simple, on peut envisager de faire en sorte que notre guerrier expose effectivement le fait qu'il soit le dépositaire d'une technique de combat, en lui donnant une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Guerrier : public Personnage{
public:
    /*il est le dépositaire d'une technique de combat,
     * il peut donc attaquer une cible (personnage ou zone)
     */
 
    void attaquer(Personnage & cible){
        techCorpACorps.attaque(cible);
    }
    void attaquer(Zone & cible){
        techCorpACorps.attaque(cible);
    }
private:
   TechniqueCorpsACorps techCorpACorps,
};

en allant "un peu plus loin", on peut aussi envisager de créer des interface permettant de mettre le dépositaire d'une technique particulière en relation avec la technique en question, ce qui nous donnerait quelque chose comme
/

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
* pour faire simple, on va considérer que le terme
 * "technicien" représente cette interface
 */
class TechnicienSoin{
public:
    void soigner(Personnage & cible){
        soins.soigner(cible);
    }
    void soigner(Zone & cible){
        soins.soigner(cible);
    }
private:
   TechniqueSoin soins;
}; 
class TechnicienSorts{
public:
    void utiliserSort(Personnage & cible){
        soins.soigner(cible);
    }
    void utiliserSort(Zone & cible){
        sorts.utiliserSort(cible);
    }
private:
   TechniqueDeSorts sorts;
}; 
template <typename TagTechnique>
class TechnicienDeCombat{
public:
 
    void attaquer(Personnage & cible){
        combats.attaque(cible);
    }
    void attaquer(Zone & cible){
        combats.attaque(cible);
    }
private:
   TechniqueDeCombat<TagTechnique> combats;
};

Et, du coup, nous pourrons définir différents types de personnages en fonction des techniques dont ils sont dépositaires sous une forme qui serait proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Guerrier : public Personnage, // un guerrier est un personnage
                                  public TechniqueDeCombat<TagCorpsACorps>> // dépositaire d'une technique de combat au corps à corps
{
/* il n'y a rien à rajouter :D */
};
class Archer: public Personnage, // un archer est un personnage
                                  public TechniqueDeCombat<TagDistance>> // dépositaire d'une technique de combat distance
{
/* il n'y a rien à rajouter :D */
}; 
class Marchand : public Personnage // un archer est un personnage
                                  public TechniqueDeCommerce// dépositaire d'une technique de commerce
{
/* il n'y a rien à rajouter :D */
};

seulement, les techniques présentées ici ont beau être correctes d'un point de vue conceptuelles, elles ne seront pas "pratiques" car il va toujours rester un problème très génant:

Au début, tu vas créer un personnage "simple": il sera guerrier ou il sera magicien ou il sera archer ou il sera commerçant. Et jusque là, il n'y aura pas de problème.

Mais que va-t-il se passer le jour où tu décide de permettre à l'un de tes personnages d'apprendre une "nouvelle technique", en permettant -- par exemple -- à ton guerrier d'utiliser des techniques de soins ou de commerce

On ne pourra pas transformer "comme par magie" un guerrier "de base" en "un guerrier soigneur" ou en un "guerrier commerçant", et donc, nous serons bloqués dans les évolutions éventuelles de notre jeu.

Comment faire le fichier cpp de guerrier ? //héritage c++

C++

Vue hybride

Discussions similaires

Partager

Partager