Model POO pour un jeu de calcul mental
Chères amies, chers amis du forum
Je reprend un vieux projet qui me tient à cœur, c-à-d un jeu de calcul mentale.
Le soucis n'est plus tellement le code mais la création d'un modèle objet robuste.
En résumé, pour l'instant j'instancie une classe Exercice composé par un pointeur vers un objet probleme, un tableau de quatre réponse possible.
L'objet probleme est constitué de deux opérandes.
Je souhaite créer, par exemple, un exercice fraction_egales ou l'on proposerais une égalité entre deux fraction avec un trou a la place du numérateur ou du dénominateur de la fraction A ou B, et le but est de trouver à partir de quatre proposition la solution.
J'ai pensé au modele suivant, chaque type d'exo comme fraction_egales, je creer une classe qui herite de Probleme, puis de mettre en virtuel les fonction commune.
Qu'en pensez vous ?
Avez vous des idées pour m'aider SVP.
Merci
Voici le code:
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
| #ifndef ExerciceH
#define ExerciceH
#include "Probleme.h"
template <class Type1,class Type2>
class Exercice
{
private :
Probleme<Type1, Type2> *m_probleme;
std::vector<Type1> m_proposition;
std::vector<Type2> m_solution;
public :
Exercice(Probleme<Type1, Type2> *probleme): m_probleme(probleme), m_proposition(4), m_solution(4)
{
m_probleme = new Probleme<Type1, Type2>(*probleme);
}
~Exercice()
{
delete m_probleme;
}
};
#endif |
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
| #ifndef ProblemeH
#define ProblemeH
#include <ctime>
#include <cmath>
#include <string>
#include <vector>
#include <cstdlib>
#include <iostream>
#include "Fraction.h"
template <class Type1, class Type2>
class Probleme
{
private:
Type1 m_operande_1;
Type2 m_operande_2;
public :
Probleme() : m_operande_1(), m_operande_2()
{
}
Probleme(const Type1& operande_1, const Type2& operande_2) : m_operande_1(operande_1), m_operande_2(operande_2)
{
}
~Probleme()
{
}
public :
virtual void Afficher() const
{
}
virtual void Resultat() const
{
}
};
#endif |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| #ifndef Fractions_egalesH
#define Fractions_egalesH
#include "Probleme.h"
class fractions_egales : public Probleme
{
public :
void Afficher() const
{
}
void Resultat() const
{
}
};
#endif |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| #include "Exercice.h"
#include "Fraction.h"
#include "Probleme.h"
int main()
{
srand(time(NULL));
Fraction a(1,2);
Fraction b(1,3);
Probleme <Fraction,Fraction> test(a,b); //Création une variable de type Probleme composé de deux type (template)
Exercice <Fraction,Fraction> Exo(&test); //Création une variable de type Exercice composé d'un Probleme dont la valeur vaut l'adresse de la variable Probleme
return 0;
} |
