Faire d'un objet d'une class mere, un objet d'une class fille.

Version imprimable

Bonjour, mon problème est le suivant:

J'ai une class mère "basePerso" qui a tout les caractéristique de n'importe quel type de personnage, j'ai aussi une class fille "guerrier" qui prend en paramétré: un string et deux int.
la construction ce passe comme sa:

Code:

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
 
// Constructeur de la class fille:
guerrier::guerrier(string name, int nb1, int nb2) : MainPerso(name, nb1, nb2) {
    m_txtr_persoB.loadFromFile("./bin/img/Personnage/Guerrier/body_s.png");
    m_txtr_persoH.loadFromFile("./bin/img/Personnage/Guerrier/hair_s.png");
    m_persoB_s.setTexture(m_txtr_persoB);
    m_persoH_s.setTexture(m_txtr_persoH);
}
 
constructeur de la class mère:
MainPerso::MainPerso(string name, int nb1, int nb2) {
    m_rdrTxtr_perso.create(32, 32);
    m_XPact=0;
    m_lvl=1;
    m_name=name;
    m_pv=m_baseIntVar[0];
    m_armure=m_baseIntVar[2];
    m_resist=m_baseIntVar[3];
    m_speed=m_baseFloatVar[0];
    m_reg=m_baseFloatVar[1];
    m_atspd=m_baseFloatVar[2];
    m_dmgMag=m_baseIntVar[4];
    m_dmgPhy=m_baseIntVar[5];
    m_clrSelect1=nb1;
    m_clrSelect2=nb2;
    upColor();
    upAnim();
    m_posAct.x=0;
    m_posAct.y=0;
    m_perso_s.setPosition(Vector2f(m_posAct.x, m_posAct.y));
}

genere une classMere en début de programme pour la spécialisé en utilisant le constructeur de la class fille, comme sa:

Code:

1
2
3
4
 
if (selectPerso==1) {
    // ici on genere la class fille grace a la class mère
}

28/06/2018, 02h18
Disixlis

Hello, je te conseil de faire un petit tour sur google et de regarder le design pattern builder, cela t'aidera :)

On ne peut pas transformer un objet de type A en un objet de type B. Même si B est une sous-classe de A.

Il faudrait effectivement regarder du côté des design patterns ce que tu pourrais trouver comme solution. Plus que Builder, je pencherais pour Factory a priori.

En C++ moderne, tu peux faire assez simplement avec une fonction template et des unique_ptr. Ca donne quelque chose comme ça :

Code:

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
#include <iostream>
#include <memory>
 
class Character {
public:
	Character(std::string name, int health) {
		std::cout << "Character" << name << ' ' << health << std::endl;
	}
 
	virtual ~Character() {
		std::cout << "~Character" << std::endl;
	}
};
 
class Warrior : public Character {
public:
	enum Weapon {
		AXE, SWORD, SPEAR
	};
 
	Warrior(std::string name, int health, Weapon weapon) :
			Character(name, health) {
		std::cout << "Warrior" << ' ' << weapon << std::endl;
	}
 
	~Warrior() {
		std::cout << "~Warrior" << std::endl;
	}
};
 
class Archer : public Character {
public:
	Archer(std::string name, int health, int arrowCount) :
			Character(name, health) {
		std::cout << "Archer" << ' ' << arrowCount << std::endl;
	}
 
	~Archer() {
		std::cout << "~Archer" << std::endl;
	}
};
 
template<typename TypeCharacter, typename ... CharacterParam>
std::unique_ptr<TypeCharacter> createCharacter(CharacterParam&&... param) {
	return std::make_unique<TypeCharacter>(param...);
}
 
int main() {
 
	std::cout << "Go!" << std::endl;
 
	{
		auto warrior = createCharacter<Warrior>("Ragnar", 100, Warrior::AXE);
		auto archer = createCharacter<Archer>("Legolas", 80, 42);
	}
 
	std::cout << "Game over" << std::endl;
}

Citation:

Go!
CharacterRagnar 100
Warrior 0
CharacterLegolas 80
Archer 42
~Archer
~Character
~Warrior
~Character
Game over

29/06/2018, 11h30
koala01

Salut,

En outre, il n'est pas vraiment opportun de charger à chaque fois les images pour tes différents personnage, ne serait-ce que parce que si tu crées mettons une armée de 1000 guerriers, tu vas te retrouver à charger ... 1000 fois l'image représentant les cheveux et autant de fois l'image représentant le corps.

Cela prendra énormément de temps, car la lecture d'un fichier qui se trouve sur le disque dur est l'accès le plus lent que l'on puisse trouver en local sur un ordinateur, et cela demandera énormément de mémoire, car, à chaque fois que tu vas charger ton image, il faudra bien ... disposer d'asser de mémoire pour représenter l'ensemble des pixels qui la composent.

Et tout cela pour rien, vu que ce sera toujours les mêmes images.

Le patron de conception "lightweight" devrait pouvoir t'aider sur ce coup ;)