Discussion :

[Nono Sto]

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 :

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
#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 :

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
#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 :

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
#ifndef Fractions_egalesH
#define Fractions_egalesH
 
#include "Probleme.h"
 
class fractions_egales : public Probleme
{
public :
	void Afficher() const
			{
			}
 
	void Resultat() const
			{
			}
};
#endif

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
#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;
}

[Emmanuel Deloget]

Si tu parles d'architecture logicielle, il serait plus efficace de proposer des schéma plutot que du code. C'est moins long à déchiffrer, à partir du moment ou tu utilises un système de notation reconnu (par exemple UML).

La classe fraction_egale doit être une classe template ou hériter d'une classe qui n'est pas template (par exemple, Probleme<Fraction,Fraction>). Et Type1, Type2 ne veut rien dire : il faudra changer ces noms, parce que ça rends le code difficilement compréhensible.

Dans ton main, fraction_egale n'apparait pas. Dans ce cas, comment savoir exactement ce que tu souhaites faire ?

En termes d'architecture, il y a là des choses dangereuses qui sont pré-supposée. Pourquoi Probleme prend-elle 2 arguments ?

[Nono Sto]

Merci

Je m'excuse pour ma réponse tardive.
J'ai essayé de résumé par un schéma fait à la main.

Plus précisément, je ne sais pas comment intégrer les différent type d'exo possible sur mon schéma j'ai opté pour une relation d'héritage.

Pour la classe Probleme elle toujours composé de deux opérande dont on ne connait pas à priori le type (fraction, double, integer), par exemple
8 + 2 = ....,
1/2 = .../4,
...+ 1/2 = 1

des possibilité et les réponse au pointillé sont donné dans les tableaux m_propositions et m_solution de l'objet exercice.

Pièce jointe 82768

Auriez vous une idées?

SVP Merci