Discussion :

[ShaiLeTroll]

Voici ce que j'écris en Delphi

Code :

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

1
2
3
4
5
6
7
8
9
10
type
  MonEnum = (meUn, meDeux, meTrois);
 
const
  MonTableau: array[MonEnum] of string = ('Un', 'Deux', 'Trois');
var
  indice: MonEnum; 
...
  for indice := Low(indice) to High(indice) do
     ShowMessage(MonTableau[indice]);

Voici ce que j'ai trouvé de plus approchant C++Builder XE

Code :

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

1
2
3
4
5
6
7
 
  enum MonEnum {meUn, meDeux, meTrois, MonEnumCount};
  String MonTableau[MonEnumCount] = {"Un", "Deux", "Trois"};
  for (MonEnum indice = meUn; indice < MonEnumCount; indice = indice + 1)
  {
    ShowMessage(MonTableau[indice]);
  }

Je trouve cela assez nul en terme de maintenance, comment avoir proprement la taille d'une énumération (ou d'un tableau) ?

pourquoi "indice++" ne fonctionne pas ?
Erreur E2277 Lvalue nécessaire

[sat83]

Je ne sais pas si ca te sera utile, mais tu peux obtenir le nombre d'élément d'un tableau par :

Code :

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

int count = sizeof( nomTab) / sizeof(nomTab[0]) ;

Mais je ne comprend pas trop ce que tu souhaite faire, ni pourquoi avoir un type énuméré lié à un tableau?

Code :

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

1
2
3
4
5
  AnsiString MonTableau[] = {"Un", "Deux", "Trois"};
 
  int count = sizeof( MonTableau) / sizeof(MonTableau[0]) ;
  for( int i = 0; i < count; i++)
    ShowMessage( MonTableau[i] ) ;

[ShaiLeTroll]

Merci, j'ai vu cette méthode du sizeof sur les forums Visual C++ !
Mais c'est sur le tableau !

En Delphi, les opérateurs Low et High permettent de récupérer la plus petite valeur d'un type énumérée et la plus grande ...

Pour la déclaration d'un tableau avec indice enuméré, j'utilise souvent cette syntaxe quand je déclare plusieurs tableaux qui doivent être utilisés conjointement (parfois j'utilise un tableaux de struct mais c'est chiant à initialiser), le compilateur averti toute de suite un oubli, utile si c'est réparti d'une plusieurs unités

en fait le code c'est

Code :

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

1
2
 enum CarriereOutils {coPelle, coPioche, coTNT, CoBarreAMine, coMasqueEtTuba, CarriereOutilsCount};
  const int OutilsDelaiMinutes[CarriereOutilsCount] = {15, 20, 25, 30, 35};

C'est plus un exercice de style, j'essaye de revoir tout ce que je connais en Delphi en C++ !

En fait, je m'inspire du code même des unités system.pas, classes.pas qui utilise massivement ce genre d'écriture.
Je n'ai que le HPP, pas les CPP

J'ai trouvé un exemple dans recerror.pas et recerror.cpp, et même dans ce code de la lib, il n'utilise pas la même structure de code !
TReconcileAction dans DBClient

Delphi 7

Code :

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

1
2
3
4
  TReconcileAction = (raSkip, raAbort, raMerge, raCorrect, raCancel, raRefresh);
 
  ActionStr: array[TReconcileAction] of string = ('Ignorer', 'Abandon', 'Fusion',
    'Correct', 'Annuler', 'Rafraîchir');

C++ XE

Code :

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

1
2
3
4
  enum TReconcileAction { raSkip, raAbort, raMerge, raCorrect, raCancel, raRefresh };
 
  char *ActionStr[] = {"Skip", "Abort", "Merge",
    "Correct", "Cancel", "Refresh"};

Donc effectivement, en C++, si ce n'est pas possible proprement, je comprends que n'en voit pas l'utilité puisque la seule utilité est d'architecturer le code et que l'on compilateur détecte les anomalies, sans méthode propre, ce n'est forcément plus viable !

j'utilise souvent une Enumération et un tableau de MetaClass lorsque j'ai besoin d'avoir des comportements prédéfinis et configurables, très courant dans les imports de fichier, le dialogue avec des robots, proche un Pattern Strategy !
Lorsque l'énumération devient trop longue ou que cela va trop changer, j'utilise un RegisterClass qui est moins facile à détecter dans le code !

Exemple
Structure conditionnelle et repétitive
Ouverture d'une TForm selon valeur d'un String
Select Case et variable évaluée

[DjmSoftware]

bonjour,

type
MonEnum = (meUn, meDeux, meTrois);

const
MonTableau: array[MonEnum] of string = ('Un', 'Deux', 'Trois');
var
indice: MonEnum;
...
for indice := Low(indice) to High(indice) do
ShowMessage(MonTableau[indice]);

A mon sens une des possibilités de traduction serait la suivante

Code :

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

1
2
3
4
5
6
7
 
 String MonTableau[MonEnumCount] = {"Un", "Deux", "Trois"};
  for (int i=0; i<MonEnumCount ; i++)
   {
	ShowMessage(MonTableau[i]);
 
   }

[Patrick Seuret]

Hello,

Je vais répéter un peu ce qui a été dit mais ajouter une explication possible pour ton "indice++" qui ne marche pas.

Le type MonEnum étant un énum, il peut être converti en un nombre mais n'en est pas vraiment un pour le compilateur et l'opérateur++ n'ayant pas été défini tu ne peut probablement pas l'utiliser sans convertir explicitement ton type.

Moi j'aime bien utiliser une notation qui me fait penser à la STL et j'aurais utilisé (les meBEGIN et meEND sont purement personnelle, ça marchera très bien sans le meBEGIN et en remplaçant meEND par MonEnumCount)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
enum MonEnum {meBEGIN=0, 
                       meUn=0, 
                       meDeux, 
                       meTrois, 
                       meEND};
  String MonTableau[meEND] = {"Un", "Deux", "Trois"};
  for (size_t indice = (size_t)meBEGIN; indice != (size_t)meEND; ++indice)
  {
    ShowMessage(MonTableau[indice]);
  }

[ShaiLeTroll]

Effectivement, prendre l'habitude de mettre un début et une fin, et je juste faire attention à les maintenir correctement (un petit commentaire)

l'astuce de forcer la numérotation est astucieuse pour le meBegin

Maintenant que je sais que ce n'est pas possible sans bidouille, j'utiliserais surement nettement pas cette technique en C++, ellle y perd tout l'intérêt que je lui trouvais en Delphi