Discussion :

[sjrd]

C'est bien cela
Un bout de tuto sur le sujet

[fab56]

Re Bonjour

J'ai fait une fonction qui transforme une expression tel que 2*3+5*6 en un tableau contenant chacun des différents élements qui sont renseignés par leur type.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
  // Le type d'un élément
  VItemType = (itNone, itNumber, itIdentifier, itUnaryOp, itBinaryOp);
  // L'élément, structure qui regroupe un descripteur de type et un variant.
  VItem = record
    ItemType: VItemType;
    ItemData: Variant;
  end;
  // Tableau dynamique d'élément.
  VItemArray = array of VItem;

Le résultat escompté est :

2*3+5*6 -->

bon là je vous montre les tableaux que j'aurai aimé obtenir

Id : Type : Valeur
[1] : itNumber : 2
[2] : itBinaryOp: "*"
[3] : itNumber : 3
[4] : itBinaryOp: "+"
[5] : itNumber : 5
[6] : itBinaryOp: "*"
[7] : itNumber : 6

Avec mon programme contenant ma fonction (qui s'appelle SplitExpresson) j'ai ceci
[1] itNumber : 2
[2] itBinaryOp : "*"
[3] itNumber : 3
[4] itBinaryOp : "+"
[5] itNumber : 5
[6] itBinaryOp : "*"

bon maintenant avec 24+33*6

j'attends

Id : Type : Valeur
[1] : itNumber : 24
[2] : itBinaryOp: "+"
[3] : itNumber : 33
[4] : itBinaryOp: "*"
[5] : itNumber : 6

mais j'ai

[1] itNone : "
[2] itNumber : "24
[3] itBinaryOp : "+
[4] itNone : "
[5] itNumber : "33
[6] itBinaryOp : "*

gloabalement elle fonctionne bien, mise à part les itNone qui n'ont rien n'a foutre là (itNone est juste un état pour préciser qu'on en est rendu au premier caractère dans la bucle, je vous laisse regarder la suite):

je voulais savoir si vous aviez des corrections à faire sur la fonction qui n'est pas encore tout à fait au point

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
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
81
82
function SplitExpression(Expression: String): VItemArray;
var
  // Le tableau des éléments de notre expression
  SplitedExpression: VItemArray;
  // Les index de boucle et le compteur de notre tableau dynamique
  ItemCount, StrLen, I: Integer;
 
  // Type du caractère courant, du caractère précédent
  CurrentType, PreviousType: VItemType;
  // ChaîneTemporaire de l'élément en cours
  CurrentItem: Variant;
 
  // Fonction qui détermine le type d'un caractère
  // de 0 à 9, itNumber
  // de A à Z, itIdentifier
  // pour | (racine) et ° (absolu), itUnaryOp (opérateurs Unaires)
  // pour +, -, *, /, %, \, ^ , itBinaryOp (opérateurs Binaires)
  function GetCharType(ExpressionChar: Char): VItemType;
  begin
    if (ExpressionChar in ['0'..'9']) then
      Result:=itNumber;
    if (ExpressionChar in ['A'..'Z','a'..'z']) then
      Result:=itIdentifier;
    if (ExpressionChar in ['|','°']) then
      Result:=itUnaryOp;
    if (ExpressionChar in ['+','-','*','/','%','\','^']) then
      Result:=itBinaryOp;
  end;
begin
  // On rensigne la longueurs de l'expression pour la boucle
  StrLen:=Length(Expression);
 
  // On initialise le compteur de notre tableau à un
  ItemCount:=1;
 
  // On met le type du caractère précédent sur itNone, logique puisque le caractère précédent le premier caractère d'une chaîne n'existe pas
  PreviousType:=itNone;
 
  // On met notre chaîne temporaire à vide
  CurrentItem:='';
 
  // On scanne la chaîne caracère après caractère
  for I:=1 to StrLen do
  begin
    // On redimensionne le tableau par rapoort au compteur
    SetLength(SplitedExpression, ItemCount);
    // On extrait le type du caractère courant
    CurrentType:=GetCharType(Expression[I]);
    // S'il n'est pas nul (itNone), (et donc si on en est plus au début de la chaîne)
    if (PreviousType <> itNone) then
      // .. si le type du caractère courant est différent du précédent
      if (CurrentType <> PreviousType) then
      begin
        // alors c'est qu'il faut qu'on créé une nouvel case du tableau dans lequel on stocke tous
        // les caractères du même type qu'on a accumulé jusqu'à présent (variable CurrentItem).
        with SplitedExpression[ItemCount-1] do
        begin
          // On caractérise notre fragment de l'expression par un type
          ItemType:=PreviousType;
          // Et on stocke la donnée dans un variant.
          ItemData:=CurrentItem;
        end;
        // Enfin, on purge notre chaîne temporaire et on y stocke notre nouveau caractère
        CurrentItem:=''+Expression[I];
 
      end
      else
        // si le type courant est du même type que le précédent
        // alors on connue à stocker dans notre chaîne temporaire
        CurrentItem:=CurrentItem+Expression[I]
    else
        //si c'est le début de la chaîne, on stocke le premier caractère dans notre chaîne temporaire.
        CurrentItem:=Expression[I];
 
    // Le type du caractère courant va devenir celui du précédent car on passe à un nouveau caractère.
    PreviousType:=CurrentType;
    // Et on incrémente notre compteur.
    Inc(ItemCount);
  end;
  // On stocke notre tableau dans le résultat de la fonction.
  Result:=SplitedExpression;
end;

[sjrd]

Quel intérêt d'utiliser les variants ? C'est plus lent que les types de base, et tu caractérise déjà son type par un ItemType. Tu devrais plutôt faire un record comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
TItem = record
  ItemType : TItemType;
  case TItemType of
    itNone : ();
    itNumber : (Value : integer); // ou tout autre type de ton choix
    itIdentifier : (Name : String[15]);
      // une chaîne longue n'est pas autorisée dans un case de record
    itUnaryOp : (UnaryOp : TUnaryOp);
    itBinaryOp : (BinaryOp : TBinaryOp);
end;

Sinon, ton code n'est pas mal

[fab56]

il me semblait bien que l'on pouvait des case...of dans des structures mais j'étais plus sûr.

Bon je met ça et je teste.

[fab56]

Bon j'admet, j'ai eu une crise de flem,

bon faut que je m'y mette. Allez, on se motive !

[fab56]

Mais par contre je les définit comment mes types TUnaryOp et TBinaryOp ?

[sjrd]

En types énumérés :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
type
  TUnaryOp = (uoPipe, upCircle); // le | et le °
  TBinaryOp = (boPlus, boMinus, boTimes, boDivide); // et d'autres

Ou en caractères si tu préfères :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
type
  TUnaryOp = type Char;
  TBinaryOp = type Char;

[fab56]

ok je vais essayé

[fab56]

bon là faut vraiment que je m'y mette. Là y a eu plein de contrôles avant les vacances. En plus j'ai mon nouveau PC qui arrive dans pas longtemps mais bon je vais essayé de vous sortir un code dans pas longtemps.

[fab56]

Non vraiment je n'arrive pas. Je suis désolé mais je préférai les Variants. Là je nage, avec un case..of dans un record l'identificateur qui vari n'a jamais le même nom, donc c'est contraignant.