Discussion :

[num_a]

bonjour, je suis très novice en delphi ..et je dois dans un programme réaliser une comparaison entre opérateurs dans le cadre d'un jeu

la classe opérateurs TC_operateur a comme sous classes les classes + et * par exemple

dans chaque sous classe sera donc définie la procédure de calcul
plus.calculer(nbr1,nbr2) ou multiplie.calculer(nbr1,nbr2), et je me demandais comment écrire la procédure TC_operateur.estprioritaire(un_operateur:TC_operateur)
dans la classe operateur, afin de définir quel opérateur est prioritaire sur l'autre lors d'une comparaison. (je connais les régles de priorité, mais ne sais pas comment transcrire tout cela en classes)

je sais pas si c'est très clair...
merci d'avance

[ShaiLeTroll]

Je dirais un truc du genre

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
type
  TC_operateur = class(TObject)
    class function IndefOfOperator(Operator: TC_operateur): TOperatorType;
    function estprioritaire(Operator: TC_operateur): boolean;   
  end:
 
  TC_plus = class(TC_operateur)
  ...  
  end;
 
  TC_multiplie = class(TC_operateur)
  ... 
  end;
 
  TC_operateur_Class = class of TC_operateur;
 
TOperatorType = (otnone, otmultiplie, otplus);
 
const
  OPERATORS_RULES = array[TOperatorType] of TC_operateur_Class = (nil, TC_multiplie, TC_plus );
 
class function TC_operateur.IndefOfOperator(Operator: TC_operateur): TOperatorType;
begin
  for Result := Low(TOperatorType) to High(TOperatorType)
    if OPERATORS_RULES[Result] = Operator.ClassType then
      Exit;
 
  Result := otnone;
end;
 
function TC_operateur.estprioritaire(Operator: TC_operateur): boolean; 
begin
  Result := IndefOfOperator(Self) < IndefOfOperator(Operator);
  // none à gérer au cas où
end;

[e-ric]

Salut

Tu peux associer un entier (rang) à chaque priorité. Pour définir, ces valeurs il te faut recenser les opérateurs, les regrouper par priorité equivalente (- et + ont la même priorité) et les trier par priorité décroissante, il va de soi que les rang reflètent la priorité :

-(unaire) : classe 3
* /: classe 2
+ - : classe 1
...

Pour chaque classe d'opérateur, tu créer une fonction de classe qui retourne le rang de priorité :

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
 
 
// essentiel pour bénéficier du polymorphisme
TC_Abstrait = class
public
  class function Priority: Integer; virtual; abstract;
end;
// Opérateur +
TC_Plus = class
public
  class function Priority: Integer; override;
end;
 
...
 
class function TC_Plus.Priority: Integer; 
begin
  Result := 3;
End;

Ce principe reste à valider par rapport à ton problème.

cdlt

[num_a]

merci beaucoup ! je vais voir ce que je peux faire