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
|
class Base
{
public:
/*trois fois rien, car elle n'est pas utilisée en tant que telle */
protected:
/*membres propres aux reste des classe, entre autres*/
Base* Parent; /*pour pouvoir remonter l'arborescence */
/* et quelques fonctions qui, dans un premier temps, remontent
l'arborescence sous forme de Parent->fonction()
pour les vérifications les plus fréquentes et qui seront surchargées,
pour la plupart dans Routine */
};
class Comment:public Base
{
/*tout ce qui va bien pour les commentaires, entre autres */
private:
std::vector<std::string> lines;
};
class FunctionCall: public Base
{
/*il s'agit ici du fait d'appeler une routine, et non de la routine
que je tente de modéliser
tout ce qui va bien pour les appels de fonction, entre autre
*/
private:
std::string nom;
std::map<std::string, SVariable> varlist;
/*les arguments doivent apparaitre dans l'ordre où il sont attendu...
ce qui interdit l'utilisation d'une map */
std::vector<SGivenArgument> varargs;
};
class Boucle: public Base
{
/* là ca se complique... parce que la boucle doit prendre
"une liste de chose à faire" qui doit pouvoir contenir n'importe
quelle chose à faire */
private:
/* mais on a au moins les parametres qui permettent de gérer la boucle
on peut envisager quelque chose sous la forme de */
enum TYPEBOUCLE{POUR,TANT,JUSQUE};
TYPEBOUCLE witchboucle;
std::vector<std::string> params;
};
class TrueFalsTest: public Base
{
/* ici, il faut une liste des choses à faire si c'est vrai, une si autre
pour c'est faux et une liste de parametres permettant de recréer le
test */
};
class MultipleChoiceTest: public Base
{
/* ici, il faut une liste de listes de choses à faire... car on ne sait
pas à l'avance combien de valeur l'utlisateur va envisager...
et pour chaque liste de choses à faire, il faut la valeur envisagée
*/
private:
std::string namevar;
};
class Routine:public Base
{
/* C'est cette classe qui sert de "racine" à l'ensemble
Enfin... Presque, parce qu'au dessus de cela, il y a un module
qui peut contenir plusieurs Routines, mais qui n'a pas de
"liste de choses à faires" (meme s'il a une foule d'autres choses) */
/* évidememnt, il faut une liste de choses à faire ici aussi */
private:
std::string nom; /* le nom de la routine */
/* les informations concernant le type renvoyé */
SReturnType typerenvoi;
/* la liste des arguments à fournir à la routine */
std::vector<SArgument> arglist;
/* la liste des variables déclarées dans la routine
"plus haut" dans l'arborescence (au niveau "module") on envisage
d'y mettre aussi les variables déclarées en global
*/
std::map<std::string, SVariable> varlist;
}; |
Modéliser une routine (fonction ou procédure)
A méditer: La solution la plus simple est toujours la moins compliquée
Répondre avec citation
Envoyé par HanLee
?
Partager