FórumSeções

Obter o número de casas decimais de quaisquer números (não apenas citações) contornando Dígitos() em MQL4 e MQL5 - página 16

Novo comentário

Aqui está outra tarefa interessante: fazer uma ordenação de matriz mais rápida do que a ArraySort integrada.

Ilya Malev:
sizeof(S)/sizeof(T)

É garantido que o tamanho de todas as estruturas seja dividido pelo tamanho de todas as variáveis?

struct SZ{
   char x1;
   char x2;
   char x3;   
};

Print(sizeof(SZ)/sizeof(int)); // 0
fxsaber:

Posso fazer um brainstorming sobre uma rápida implementação da tradução de uma série de estruturas (comprimento múltiplo de tamanho do(int)) de e para uma série int[]?

///

Simplesmente depois de descrever uma estrutura, escreva mais algumas linhas com um sindicato que inclua esta estrutura e uma matriz.

struct SS{
   int a;
   double b;
};

union UX{
   SS s;
   char a[sizeof(S)];
};


É possível até mesmo não escrever depois de cada estrutura, mas sim modelá-la - o que for conveniente para você.

Dmitry Fedoseev:

O tamanho de todas as estruturas é garantido dividido pelo tamanho de todas as variáveis?

Fórum sobre Comércio, Sistemas Automatizados de Comércio e Testes de Estratégia

Obtendo o número de casas decimais de quaisquer números (não apenas citações) contornando dígitos() em MQL4 e MQL5

fxsaber, 2018.12.07 15:12

Posso fazer um brainstorming sobre uma implementação rápida para converter um conjunto de estruturas (comprimento múltiplo de tamanho do(int)) para e de um conjunto int[]?

Em geral, a solução está no mesmo elo, mas devido à versatilidade, há um freio ali. Portanto, a multiplicidade é uma condição adicional compreensível.

Isto também apareceu.

Fórum sobre comércio, sistemas automatizados de comércio e testes estratégicos

Nova versão do MetaTrader 5 build 1930: Janela de gráficos flutuantes e biblioteca .Net em MQL5

MetaQuotes Software Corp., 2018.10.25 17:18

  1. MQL5: A propriedade pack( integer_value ) foi adicionada para estruturas. Permite definir o alinhamento dos campos dentro da estrutura, pode ser necessário quando se trabalha com DLL. Para valor_inteiro pode ter valores 1, 2, 4, 8 e 16.
    Se a propriedade não estiver definida, o alinhamento padrão é de 1 byte - pacote(1).

    Exemplo de uso:
    //+------------------------------------------------------------------+
//| Default packing                                                  |
//+------------------------------------------------------------------+
struct A
  {
   char              a;
   int               b;
  };
//+------------------------------------------------------------------+
//| Specified packing                                                |
//+------------------------------------------------------------------+
struct B pack(4)
  {
   char              a;
   int               b;
  };
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   Print("sizeof(A)=",sizeof(A));
   Print("sizeof(B)=",sizeof(B));
  }
//+------------------------------------------------------------------+
    Saída:
    sizeof(A)=5
sizeof(B)=8
    Mais informações sobre alinhamento em estruturas estão disponíveis em MSDN.
Dmitry Fedoseev:

Basta, depois de descrever a estrutura, escrever mais algumas linhas com um sindicato que inclua esta estrutura e a matriz.

Você pode até mesmo não escrever depois de cada estrutura, mas sim, modelá-la - o que for mais conveniente.

Eu não entendo. Se você quiser participar, por favor, escreva sua variante.

fxsaber:

Posso fazer um brainstorming sobre uma rápida implementação da tradução de um conjunto de estruturas (comprimento múltiplo de tamanho do(int)) de e para o conjunto int[]?

por que int... e não para carater...

(e será mais longo - será copiado mais rapidamente)

Ilya Malev:

Aparentemente, o seu já é mais rápido :)

// Перевод массива тиков в массив int[].
int TicksToIntArray_fxsaber3( const MqlTick &Ticks[], int &Array[] )
{
  INTEGER<MqlTick> TickInteger;

  const int Size = ArraySize(Ticks);
  ArrayResize(Array, Size * sizeof(MqlTick) / sizeof(int));
  
  int j = 0;

  for (int i = 0; i < Size; i++)
  {
    TickInteger.Data = Ticks[i];

//    j += ArrayCopy(Array, TickInteger.Integer, j);
    for (int k = 0; k < sizeof(MqlTick) / sizeof(int); k++)
      Array[j++] = TickInteger.Integer[k];
  }

  return(j);
}

// Перевод массива int[] в массив тиков.
int IntArrayToTicks_fxsaber3( const int &Array[], MqlTick &Ticks[] )
{
  INTEGER<MqlTick> TickInteger = {0};

  const int Size = ArraySize(Array);
  ArrayResize(Ticks, Size * sizeof(int) / sizeof(MqlTick));
  
  int j = 0;

  for (int i = 0; i < Size; j++)
  {
//    i += ArrayCopy(TickInteger.Integer, Array, 0, i, sizeof(MqlTick) / sizeof(int));
    for (int k = 0; k < sizeof(MqlTick) / sizeof(int); k++)
      TickInteger.Integer[k] = Array[i++];

    Ticks[j] = TickInteger.Data;
  }

  return(j);
}


Vou tentar agilizar consideravelmente.

fxsaber:

Eu não entendo. Se você gostaria de participar, por favor escreva sua opção.

Eu fiz.

fxsaber:

No caso geral, a solução está no mesmo elo, mas por causa da universalidade existem freios. Portanto, a multiplicidade é uma condição adicional compreensível.

Isto também aparece.

Quem controlará essa multiplicidade?

1...910111213141516171819202122
Novo comentário