Como é que passo por uma enumeração de forma consistente? - página 2

Novo comentário
 

E com um pouco mais de trabalho cerebral, pode obter uma função 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:

E, se aumentar um pouco mais o seu cérebro, pode obter a seguinte função

Porquê 

return(0)

Uma vez que a função é int, que o regresso também faça o truque.

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 a chamada é provavelmente assim

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

o resultado é

 мин=60  ENUM=16385  string=H1
 
Nas enumerações, há uma discussão:
1) introduzindo ++ para enumeração
2) conversão da enumeração em cordel 
ENUM_TIMEFRAMES t=PERIOD_M1;
string s=(string)t;

s будет иметь значение "PERIOD_M1"
 
mql5:
Nas enumerações, há uma discussão:
1) introduzindo ++ para enumeração
2) conversão da enumeração em cordel

Forte apoio. Especialmente o primeiro ponto. Existem centenas de enumerações apenas no pacote padrão, e é demasiado caro escrever uma função separada para cada enumeração.
 
Ilyas:
Sobre transferências, há uma discussão:
1) introduzindo ++ para enumeração


Será que esta funcionalidade já está em vigor?

Ou outra alternativa para listar itens sequencialmente?

 
Dê-nos iteradores!
 

Parece-me que incrementar uma enumeração não é o passo certo.

A enumeração por defeito não tem necessariamente de ser sequencial, e além disso, durante o desenvolvimento - os valores podem ser-lhe adicionados "no meio".

Claro que, para "simplificar", seria bom obter o "próximo" valor imediato através do aumento da contagem, mas na minha opinião, esta é uma prática potencialmente perigosa.

Para obter o "próximo valor" na enumeração, o mais razoável é utilizar uma função especial, como já foi aqui mencionado.

E as pessoas parecem ignorar o selector por defeito, e em vão. Cada interruptor() deve conter este selector com um aviso de que chegou um valor obscuro.

 

George Merts:

aumentando as enumerações - obtendo o valor "seguinte" imediatamente

Era isso queIlyas queria dizer.

Tinha uma pergunta para ele ou para o promotor responsável. Este problema foi resolvido - de alguma forma para passar por todos os elementos programáticos ou ainda está no processo...

Não me interessa realmente como passar

operador de foreach

novas funções como GetNextEnum / GetLastEnum / GetFirstEnum

ou sobrecarga ++

desde que não seja como foi sugerido acima - desenhar funções para as denominações actuais e depois ter medo que nada se quebre quando estas forem actualizadas pelos criadores

 

Meu Deus, porquê tais complexidades - alguns aldrabões, iteradores... A solução mais óbvia e flexível é introduzir na linguagem uma função que consiga todos os valores de enumeração numa matriz. E depois decidir como atravessar essa matriz, mesmo transversalmente.Além disso, vai ter de guardar todos os valores de qualquer maneira, uma vez que não vai voltar a guardar tudo em todas as chamadas. Uma vez ultrapassado, guardado, e depois basta tirá-lo da matriz. Então não é mais fácil obter uma matriz pronta de uma vez?

A propósito, a variante com sobrecarga do operador ++ pode causar um trabalho incorrecto dos programas existentes, pelo que é uma forma extremamente má.

Bem, os exemplos aqui mostrados (caso 1: valor de retorno1; caso 2: valor de retorno2; caso 3: valor de retorno3... Uma pessoa adequada colocaria todos os valores numa matriz e obteria apenas o valor necessário pelo seu índice, enquanto que para a tarefa inversa utilizaria a pesquisa binária.

 
Alexey Navoykov:

Deus, que complexidade é esta - os prós, os contras...

Não me interessa como quer que seja.

Bem, os exemplos aqui mostrados (caso 1: valor de retorno1; caso 2: valor de retorno2; caso 3: valor de retorno3... Uma pessoa adequada colocaria todos os valores numa matriz e obteria apenas o valor necessário pelo seu índice, enquanto que uma pesquisa binária será utilizada para a tarefa inversa.

a troca é uma coisa muito eficaz
12345678
Novo comentário