Comment faire pour passer une énumération de manière cohérente ? - page 2

Nouveau commentaire
 

Et avec un peu plus de travail de réflexion, vous pouvez obtenir une fonction comme celle-ci

int GetPeriodEnumerator(
uchar i,              // индекс перечисления 
ENUM_TIMEFRAMES &tf,  // сюда принимаем числовое значение таймфрейма 
string &tfs           // сюда принимаем строковое значение таймфрейма
)
  {
   switch(i)
     {
      case 0:  {tf=PERIOD_M1;tfs="M1";return(0);}
      case 1:  {tf=PERIOD_M2;tfs="M2";return(0);}
      case 2:  {tf=PERIOD_M3;tfs="M3";return(0);}
      case 3:  {tf=PERIOD_M4;tfs="M4";return(0);}
      case 4:  {tf=PERIOD_M5;tfs="M5";return(0);}
      case 5:  {tf=PERIOD_M6;tfs="M6";return(0);}
      case 6:  {tf=PERIOD_M10;tfs="M10";return(0);}
      case 7:  {tf=PERIOD_M12;tfs="M12";return(0);}
      case 8:  {tf=PERIOD_M15;tfs="M15";return(0);}
      case 9:  {tf=PERIOD_M20;tfs="M20";return(0);}
      case 10: {tf=PERIOD_M30;tfs="M30";return(0);}
      case 11: {tf=PERIOD_H1;tfs="H1";return(0);}
      case 12: {tf=PERIOD_H2;tfs="H2";return(0);}
      case 13: {tf=PERIOD_H3;tfs="H3";return(0);}
      case 14: {tf=PERIOD_H4;tfs="H4";return(0);}
      case 15: {tf=PERIOD_H6;tfs="H6";return(0);}
      case 16: {tf=PERIOD_H8;tfs="H8";return(0);}
      case 17: {tf=PERIOD_H12;tfs="H12";return(0);}
      case 18: {tf=PERIOD_D1;tfs="D1";return(0);}
      case 19: {tf=PERIOD_W1;tfs="W1";return(0);}
      case 20: {tf=PERIOD_MN1;tfs="MN1";return(0);}
     }
   return(-1);
  }
 
sergey1294:

Et si vous vous creusez un peu plus la tête, vous pouvez obtenir la fonction suivante

Pourquoi 

return(0)

Puisque la fonction est int, laissez return faire l'affaire aussi.

int GetPeriodEnumerator(
uchar i,              // индекс перечисления 
ENUM_TIMEFRAMES &tf,  // сюда принимаем числовое значение таймфрейма 
string &tfs           // сюда принимаем строковое значение таймфрейма
)
  {
   switch(i)
     {
      case 0:  {tf=PERIOD_M1;tfs="M1";return(PeriodSeconds(tf)/60);}
      case 1:  {tf=PERIOD_M2;tfs="M2";return(PeriodSeconds(tf)/60);}
      case 2:  {tf=PERIOD_M3;tfs="M3";return(PeriodSeconds(tf)/60);}
      case 3:  {tf=PERIOD_M4;tfs="M4";return(PeriodSeconds(tf)/60);}
      case 4:  {tf=PERIOD_M5;tfs="M5";return(PeriodSeconds(tf)/60);}
      case 5:  {tf=PERIOD_M6;tfs="M6";return(PeriodSeconds(tf)/60);}
      case 6:  {tf=PERIOD_M10;tfs="M10";return(PeriodSeconds(tf)/60);}
      case 7:  {tf=PERIOD_M12;tfs="M12";return(PeriodSeconds(tf)/60);}
      case 8:  {tf=PERIOD_M15;tfs="M15";return(PeriodSeconds(tf)/60);}
      case 9:  {tf=PERIOD_M20;tfs="M20";return(PeriodSeconds(tf)/60);}
      case 10: {tf=PERIOD_M30;tfs="M30";return(PeriodSeconds(tf)/60);}
      case 11: {tf=PERIOD_H1;tfs="H1";return(PeriodSeconds(tf)/60);}
      case 12: {tf=PERIOD_H2;tfs="H2";return(PeriodSeconds(tf)/60);}
      case 13: {tf=PERIOD_H3;tfs="H3";return(PeriodSeconds(tf)/60);}
      case 14: {tf=PERIOD_H4;tfs="H4";return(PeriodSeconds(tf)/60);}
      case 15: {tf=PERIOD_H6;tfs="H6";return(PeriodSeconds(tf)/60);}
      case 16: {tf=PERIOD_H8;tfs="H8";return(PeriodSeconds(tf)/60);}
      case 17: {tf=PERIOD_H12;tfs="H12";return(PeriodSeconds(tf)/60);}
      case 18: {tf=PERIOD_D1;tfs="D1";return(PeriodSeconds(tf)/60);}
      case 19: {tf=PERIOD_W1;tfs="W1";return(PeriodSeconds(tf)/60);}
      case 20: {tf=PERIOD_MN1;tfs="MN1";return(PeriodSeconds(tf)/60);}
     }
   return(-1);
  }

et l'appel est probablement comme ceci

   ENUM_TIMEFRAMES tf;
   string tfs;
   Print(" мин=",GetPeriodEnumerator(11,tf,tfs),"  ENUM=",tf,"  string=",tfs);

le résultat est

 мин=60  ENUM=16385  string=H1
 
Sur les énumérations, il y a une discussion :
1) introduction de ++ pour l'énumération
2) conversion de l'énumération en chaîne de caractères 
ENUM_TIMEFRAMES t=PERIOD_M1;
string s=(string)t;

s будет иметь значение "PERIOD_M1"
 
mql5:
Sur les énumérations, il y a une discussion :
1) introduction de ++ pour l'énumération
2) conversion de l'énumération en chaîne de caractères

Soutien ferme. Surtout le premier point. Il existe des centaines d'énumérations dans le seul paquetage standard, et il est trop coûteux d'écrire une fonction distincte pour chaque énumération.
 
Ilyas:
Sur les transferts, il y a une discussion :
1) introduction de ++ pour l'énumération


Cette fonctionnalité est-elle déjà en place ?

Ou une autre alternative pour lister les éléments de manière séquentielle ?

 
Donnez-nous des itérateurs !
 

Il me semble que l'incrémentation d'une énumération n'est pas la bonne démarche.

L'énumération par défaut ne doit pas nécessairement être séquentielle, et d'ailleurs, au cours du développement - des valeurs peuvent y être ajoutées "en cours de route".

Bien sûr, pour "simplifier", il serait agréable d'obtenir la valeur "suivante" immédiate en incrémentant l'énumération, mais à mon avis, c'est une pratique potentiellement dangereuse.

Pour obtenir la "valeur suivante" dans l'énumération, la chose la plus raisonnable est d'utiliser une fonction spéciale, comme déjà mentionné ici.

Et les gens semblent ignorer le sélecteur par défaut, et en vain. Chaque switch() doit contenir ce sélecteur avec un avertissement qu'une valeur obscure est arrivée.

 

George Merts:

en incrémentant les énumérations - en obtenant immédiatement la valeur "suivante".

C'est ce qu'Ilyas voulait dire.

J'avais une question pour lui ou le développeur en charge. Ce problème a-t-il été résolu - d'une manière ou d'une autre pour passer par tous les éléments de manière programmatique ou est-il toujours en cours...

Je ne me soucie pas vraiment de savoir comment passer

opérateur foreach

de nouvelles fonctions comme GetNextEnum / GetLastEnum / GetFirstEnum

ou surcharge ++

tant que ce n'est pas comme suggéré ci-dessus - dessiner des fonctions pour les dénominations actuelles et ensuite avoir peur que rien ne casse lorsqu'elles sont mises à jour par les développeurs

 

Mon Dieu, pourquoi de telles complexités - des plus, des itérateurs... La solution la plus évidente et la plus flexible est d'introduire dans le langage une fonction qui récupère toutes les valeurs de l'énumération dans un tableau. Et ensuite vous décidez comment parcourir ce tableau, même de manière croisée.De plus, vous allez devoir sauvegarder toutes les valeurs de toute façon, puisque vous n'allez pas tout hacher à chaque appel. Une fois que vous l'avez contourné, stocké, et ensuite vous le prenez simplement dans le tableau. Donc, n'est-il pas plus facile d'obtenir un tableau prêt en une seule fois ?

À propos, la variante avec surcharge de l'opérateur ++ peut entraîner un fonctionnement incorrect des programmes existants, c'est donc une très mauvaise méthode.

Eh bien, les exemples montrés ici (cas 1 : valeur de retour1 ; cas 2 : valeur de retour2 ; cas 3 : valeur de retour3... Une personne compétente placerait toutes les valeurs dans un tableau et obtiendrait simplement la valeur requise par son index, tandis que pour la tâche inverse, elle utiliserait la recherche binaire.

 
Alexey Navoykov:

Mon dieu, c'est quoi toute cette complexité - les plus, les itérateurs...

Je me fiche de savoir comment tu veux que ce soit.

Eh bien, les exemples montrés ici (cas 1 : valeur de retour1 ; cas 2 : valeur de retour2 ; cas 3 : valeur de retour3... Une personne compétente placerait toutes les valeurs dans un tableau et obtiendrait simplement la valeur requise par son index, tandis qu'une recherche binaire serait utilisée pour la tâche inverse.

l'interrupteur est une chose très efficace
12345678
Nouveau commentaire