Come si fa a passare un'enumerazione in modo coerente? - pagina 2

Nuovo commento
 

E con un po' più di lavoro di cervello, si può ottenere una funzione come questa

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:

E se vi scervellate un po' di più potete ottenere la seguente funzione

Perché 

return(0)

Dato che la funzione è int, lasciamo che anche return faccia il trucco.

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

e la chiamata è probabilmente come questa

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

il risultato è

 мин=60  ENUM=16385  string=H1
 
Sulle enumerazioni, c'è una discussione:
1) introdurre ++ per l'enumerazione
2) conversione di enumerazione in stringa 
ENUM_TIMEFRAMES t=PERIOD_M1;
string s=(string)t;

s будет иметь значение "PERIOD_M1"
 
mql5:
Sulle enumerazioni, c'è una discussione:
1) introdurre ++ per l'enumerazione
2) conversione di enumerazione in stringa

Sostenere con forza. Soprattutto il primo punto. Ci sono centinaia di enumerazioni solo nel pacchetto standard, ed è troppo costoso scrivere una funzione separata per ogni enumerazione.
 
Ilyas:
Sui trasferimenti, c'è una discussione:
1) introdurre ++ per l'enumerazione


Questa funzionalità è già presente?

O un'altra alternativa per elencare gli elementi in modo sequenziale?

 
Dateci degli iteratori!
 

Mi sembra che incrementare un'enumerazione non sia il passo giusto.

L'enumerazione predefinita non deve necessariamente essere sequenziale, e inoltre, durante lo sviluppo - i valori possono essere aggiunti ad essa "nel mezzo".

Certo, per "semplificare" sarebbe bello ottenere un valore "prossimo" immediato incrementando l'enumerazione, ma a mio parere, questa è una pratica potenzialmente pericolosa.

Per ottenere il "prossimo valore" nell'enumerazione, la cosa più ragionevole è usare una funzione speciale, come già detto qui.

E la gente sembra ignorare il selettore di default, e invano. Ogni switch() deve contenere questo selettore con un avviso che un valore oscuro è arrivato.

 

George Merts:

incrementando le enumerazioni - ottenendo immediatamente il "prossimo" valore

Questo è ciò che intendevaIlyas .

Avevo una domanda per lui o per lo sviluppatore responsabile. Questo problema è stato risolto - in qualche modo per passare attraverso tutti gli elementi programmaticamente o è ancora nel processo...

Non mi interessa molto come passare

operatore foreach

nuove funzioni come GetNextEnum / GetLastEnum / GetFirstEnum

o sovraccarico ++

purché non sia come è stato suggerito sopra - disegnare funzioni per le denominazioni attuali e poi avere paura che non si rompa nulla quando vengono aggiornate dagli sviluppatori

 

Dio, perché tanta complessità - alcuni plusser, iteratori... La soluzione più ovvia e flessibile è introdurre nel linguaggio una funzione che prenda tutti i valori di enumerazione in un array. E poi si decide come attraversare questo array, anche trasversalmente.Inoltre, dovrai salvare tutti i valori in ogni caso, dato che non hai intenzione di ri-hashare tutto ad ogni chiamata. Una volta che l'hai bypassato, memorizzato, e poi lo prendi semplicemente dall'array. Quindi non è più facile ottenere un array pronto in una volta?

A proposito, la variante con sovraccarico dell'operatore ++ può causare un lavoro scorretto dei programmi esistenti, quindi è un modo estremamente cattivo.

Bene, gli esempi mostrati qui (caso 1: ritorno valore1; caso 2: ritorno valore2; caso 3: ritorno valore3... Una persona adeguata metterebbe tutti i valori in un array e otterrebbe semplicemente il valore necessario in base al suo indice, mentre per il compito inverso userebbe la ricerca binaria.

 
Alexey Navoykov:

Dio, cos'è tutta questa complessità - i plus, gli iteratori...

Non mi interessa come volete che sia.

Bene, gli esempi mostrati qui (caso 1: ritorno valore1; caso 2: ritorno valore2; caso 3: ritorno valore3... Una persona adeguata metterebbe tutti i valori in un array e otterrebbe semplicemente il valore necessario in base al suo indice, mentre una ricerca binaria verrebbe usata per il compito inverso.

l'interruttore è una cosa molto efficace
12345678
Nuovo commento