¿Cómo puedo pasar por una enumeración de forma coherente? - página 2

Nuevo comentario
 

Y con un poco más de trabajo mental, puedes conseguir una función como esta

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:

Y si se devanan los sesos un poco más se puede conseguir la siguiente función

Por qué 

return(0)

Dado que la función es int, deja que return haga el truco también.

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);
  }

y la llamada es probablemente así

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

el resultado es

 мин=60  ENUM=16385  string=H1
 
Sobre las enumeraciones, hay una discusión:
1) introducción de ++ para la enumeración
2) conversión de la enumeración en cadena 
ENUM_TIMEFRAMES t=PERIOD_M1;
string s=(string)t;

s будет иметь значение "PERIOD_M1"
 
mql5:
Sobre las enumeraciones, hay una discusión:
1) introducción de ++ para la enumeración
2) conversión de la enumeración en cadena

Apoyar firmemente. Especialmente el primer punto. Sólo en el paquete estándar hay cientos de enumeraciones, y es demasiado caro escribir una función distinta para cada enumeración.
 
Ilyas:
Sobre las transferencias, hay una discusión:
1) introducción de ++ para la enumeración


¿Existe ya esta funcionalidad?

¿O otra alternativa para enumerar los elementos secuencialmente?

 
¡Danos iteradores!
 

Me parece que el incremento para una enumeración no es el paso correcto.

La enumeración por defecto no tiene que ser necesariamente secuencial, y además, durante el desarrollo - se pueden añadir valores a la misma "en el medio".

Por supuesto, para "simplificar" estaría bien obtener el "siguiente" valor inmediato incrementando la enumeración, pero en mi opinión, esta es una práctica potencialmente peligrosa.

Para obtener el "siguiente valor" en la enumeración, lo más razonable es utilizar una función especial, como ya se ha mencionado aquí.

Y la gente parece ignorar el selector por defecto, y en vano. Cada switch() debe contener este selector con un aviso de que ha llegado un valor oscuro.

 

George Merts:

incrementando las enumeraciones - obteniendo el "siguiente" valor inmediatamente

Eso es lo que quería decirIlyas .

Tenía una pregunta para él o para el promotor responsable. ¿Se ha resuelto este problema - de alguna manera para ir a través de todos los elementos programáticamente o está todavía en el proceso...

Realmente no me importa cómo pasar

operador foreach

nuevas funciones como GetNextEnum / GetLastEnum / GetFirstEnum

o sobrecarga ++

siempre y cuando no sea como se ha sugerido más arriba: dibujar funciones para las denominaciones actuales y luego tener miedo de que no se rompa nada cuando sean actualizadas por los desarrolladores

 

Dios, por qué tanta complejidad - algunos plussers, iteradores... La solución más obvia y flexible es introducir en el lenguaje una función que obtenga todos los valores de la enumeración en un array. Y luego decidir cómo recorrer este array, incluso transversalmente.Además, vas a tener que guardar todos los valores de todos modos, ya que no vas a rehacer todo en cada llamada. Una vez que lo has pasado, lo has guardado, y luego simplemente lo tomas del array. Entonces, ¿no es más fácil obtener un array listo de una vez?

Por cierto, la variante con sobrecarga de operadores ++ puede causar un trabajo incorrecto de los programas existentes, por lo que es una forma extremadamente mala.

Pues bien, los ejemplos mostrados aquí (caso 1: devolver valor1; caso 2: devolver valor2; caso 3: devolver valor3... Una persona adecuada pondría todos los valores en un array y sólo obtendría el valor necesario por su índice, mientras que para la tarea inversa utilizará la búsqueda binaria.

 
Alexey Navoykov:

Dios, a qué viene tanta complejidad: los pluses, los iteradores...

No me importa cómo quieras que sea.

Pues bien, los ejemplos mostrados aquí (caso 1: devolver valor1; caso 2: devolver valor2; caso 3: devolver valor3... Una persona adecuada pondría todos los valores en un array y sólo obtendría el valor necesario por su índice, mientras que para la tarea inversa se utilizará una búsqueda binaria.

el cambio es algo muy efectivo
12345678
Nuevo comentario