[Builder6] Optimisation du code

Version imprimable

Bonjour à tous, je viens vers vous afin d'optimiser mon code, car je le trouve très répétitif et je pense que l'on doit pouvoir le réduire très fortement avec un switch ou autre mais je ne vois pas comment le mettre en place.

Voici mon 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
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("3 KVA ST"))
      {
            PrixAbo = Abo3KVA;
            TarifHC = PrixHC3;
            TarifHP = PrixHP3;
            EditPrixHC->Enabled=false;
 
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("6 KVA ST"))
      {
            PrixAbo = Abo6KVA;
            TarifHC = PrixHC3;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=false;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("9 KVA ST"))
      {
            PrixAbo = Abo9KVA;
            TarifHC = PrixHC3;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=false;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("12 KVA ST"))
      {
            PrixAbo = Abo12KVA;
            TarifHC = PrixHC3;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=false;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("15 KVA ST"))
      {
            PrixAbo = Abo15KVA;
            TarifHC = PrixHC3;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=false;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("18 KVA ST"))
      {
            PrixAbo = Abo18KVA;
            TarifHC = PrixHC3;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=false;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("24 KVA ST"))
      {
            PrixAbo = Abo24KVA;
            TarifHC = PrixHC3;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=false;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("30 KVA ST"))
      {
            PrixAbo = Abo30KVA;
            TarifHC = PrixHC3;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=false;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("36 KVA ST"))
      {
            PrixAbo = Abo36KVA;
            TarifHC = PrixHC3;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=false;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("6 KVA DT"))
      {
            PrixAbo = Abo6KVADT;
            TarifHC = PrixHC;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=true;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("9 KVA DT"))
      {
            PrixAbo = Abo9KVADT;
            TarifHC = PrixHC;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=true;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("12 KVA DT"))
      {
            PrixAbo = Abo12KVADT;
            TarifHC = PrixHC;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=true;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("15 KVA DT"))
      {
            PrixAbo = Abo15KVADT;
            TarifHC = PrixHC;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=true;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("18 KVA DT"))
      {
            PrixAbo = Abo18KVADT;
            TarifHC = PrixHC;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=true;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("24 KVA DT"))
      {
            PrixAbo = Abo24KVADT;
            TarifHC = PrixHC;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=true;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("30 KVA DT"))
      {
            PrixAbo = Abo30KVADT;
            TarifHC = PrixHC;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=true;
      }
      if (ComboPuissance->ItemIndex == ComboPuissance->Items->IndexOf("36 KVA DT"))
      {
            PrixAbo = Abo36KVADT;
            TarifHC = PrixHC;
            TarifHP = PrixHP;
            EditPrixHC->Enabled=true;
      }

Merci par avance de votre aide :oops:

03/09/2007, 12h22
bandit boy
Salut,
En effet, il est possible de simplifier la présentation tout en gardant de la clareter. Le soucis est que tu auras autant de version que de programmeur :lol:

Il semble que tu connaisses l'item de la ComboBox et comme tu as écrit toi-même la comboBox, tu connais l'endroit des chaînes:
Code:

1 2 3 4 5 6 7 8 9 10 11 switch(ComboPuissance->ItemIndex) { case 0://première chaine ... break; case 1://deuxième chaine ... break; ... }
03/09/2007, 13h40
henderson
Salut !

C'est d'utiliser des tableaux (sans doute de pointeurs) pour éviter aussi le switch !

Pour ce qui est du Enabled, on peut faire une évaluation booléenne.
Donc globalement on serait amené à pouvoir résumer l'ensemble en faisant :
Code:

1 2 3 4 5 6 7 8 9 int n = ComboPuissance->ItemIndex; //séquence commune TarifHC = PrixHC; TarifHP = PrixHP; //séquence propre Val2 = *Valeurs2[n]; //le bool EditPrixHC->Enabled = ( n > ...);
A plus !
03/09/2007, 16h32
bandit boy

Tu peux aussi faire une fonction qui teste la chaîne et te renvoie un index (un int ou un type enum) qui te permet de faire ton switch.
04/09/2007, 00h15
batmat86

Bonjour et merci de vos réponses :D

Par contre je dois admettre que je ne vois pas trop comment les mettrent en place.

Pour ta solution bandit boy, je pense voir comment faire, mais au final cela va juste me supprimer tout mes If et les remplacer par les case, mais j'aurais toujours toutes les parties identiques selon les cas à copier coller comme c'est le cas actuellement.

Au final ce que je cherche à faire car à mon avis cela doit être possible, ce serait d'avoir le moins de ligne de code possible pour arriver au même résultat que j'ai actuellement, car je dois admettre que la syntaxe de mon code doit faire peur aux développeurs expérimentés que vous êtes :oops:

En ce qui concerne ta solution henderson, là je dois admettre que les pointeurs a toujours été ma béte noire en programmation pendant mon bts et je n'y avais jamais rien compris. Alors maintenant que j'ai eu mon bts il y a 2 ans et codant que très très peu pour me faciliter le boulot, je dois dire que je suis perdu pour une telle solution.

Donc si vous avez un exemple à me donner je pense que je pourrais m'adapter et ainsi faire l'optimisation souhaitait car selon moi on doit pour réduire presque de moitié mon code.

Merci en tout cas de votre aide, cela fait plaisir ;)
04/09/2007, 11h18
bandit boy

Il faut que tu poses tout ca comme il faut, sachant que tu peux tester très facilement des chaîne de caractères.

J'ai remarqué que tu écris souvent la même chose et que tu as en fait 4 paramètres à conficgurer. Pose un tableau (type table de bool) et simplifie au maximum le teste pour finalement travailler non pas sur une configuration, mais une option.

A toi de retourner le problème
04/09/2007, 14h37
henderson
Salut !

Suposons que l'on ait 3 variables utiles et suffisantes :
Code:

1 2 3 4 int val1 = 100; int val2 = 45; int val3 = 78;
Supposons que l'on ait 5 cas :

cas1 utilise val1
cas2 utilise val2
cas3 utilise val3
cas4 utilise val1
cas5 utilise val3

Si on utilise un tableau de variables pour gérer l'ensemble des cas à l'aide d'un simple index, on est amené à le remplir de cette manière (ou d'une autre) :
Code:

1 2 int tab[] = {100,45,78,100,78};
Le problème est que si on a besoin de modifier val1, il faudra mettre à jour les éléments du tableau qui correspondent à val1, et dans ce cas précis : tab[0], tab[3].
Ce qui peut ne pas être très pratique.

Par contre, un tableau de pointeurs va permettre d'accéder aux variables à l'aide de leur adresse (donc de façon indirecte) :
Code:

1 2 int *tab[] = {&val1, &val2, &val3, &val1, &val3};
On pourra donc éventuellement modifier val1 (on est toujours dans cette supposition) tout en sachant que tab[0] et tab[3] donneront la valeur de val1 grâce à cette indirection.
Code:

1 2 3 4 5 int valeur; val1 = 50; //je modifie val1 valeur = *tab[0]; // accède indirectement à val1 via l'adresse de val1 contenue dans tab[0] valeur = *tab[3]; // idem mais via tab[3]
Bien entendu, si chaque cas nécessite une valeur qui lui est propre, dans ce cas un simple tableau est suffisant !

A plus !