Perguntas de Iniciantes MQL5 MT5 MetaTrader 5 - página 1201

Novo comentário
 
Сергей Таболин:

Escrevo tudo num só ficheiro. Escrever, e depois ler, várias estruturas para o mesmo ficheiro corre bem.

Mas lê a matriz do princípio ao fim. Como é que se divide em 3 partes? Como se escreveu uma estrutura e se conseguiu escrever uma matriz para o mesmo ficheiro? Sou autodidacta, não sei muito, mas o facto de serem formatos de dados diferentes, de alguma forma suspeito.

Admito que se consegue abrir o ficheiro para escrever uma vez e enfiar três arrays nele, mas não se pode simplesmente lê-lo em partes como essa.

 
Alexey Viktorov:

Mas lê a matriz do princípio ao fim. Como é que se divide em 3 partes? Como se escreve uma estrutura e se consegue escrever uma matriz para o mesmo ficheiro? Sou autodidacta, não sei muito, mas o facto de que são formatos de dados diferentes, de alguma forma suspeito.

Admito que posso escapar-me abrindo um ficheiro para escrever uma vez e enfiar-lhe três matrizes, mas não consigo lê-lo tão facilmente em partes.

Digo, se escrever no mesmo ficheiro apenas 1 estrutura e 3 matrizes, então pode lê-las a partir daí (assumindo que para ler as matrizes tem de especificar o tamanho de cada uma). Mas o truque de escrever e depois ler várias dessas sequências não funcionou para mim. Talvez precise de mover o ponteiro, mas já está tenso...

 
Сергей Таболин:

Eu disse-lhe, se escrever apenas 1 estrutura e 3 matrizes num ficheiro, então pode lê-las mais tarde (desde que tenha de especificar o tamanho de cada uma delas para ler as matrizes). Mas o truque de escrever e depois ler várias dessas sequências não funcionou para mim. Talvez precise de mover o ponteiro, mas isso é um pouco incómodo...

Como é que está tenso? Não tem cavalos de potência suficiente? E como se pode ter a certeza de que a escrita foi bem sucedida e como se pode supor isso se a leitura falhou? Tanto quanto sei, não se pode olhar para um ficheiro .bin com os olhos.

 
Сергей Таболин:

Artyom, pode dar-me um exemplo? Tendo em conta que o tamanho das matrizes é dinâmico.

Não, ainda não haverá exemplos - eu próprio ainda não o fiz, e quando o fizer, irei descrevê-lo nos meus artigos. E não será em breve. O facto é que só se podem escrever estruturas POD num ficheiro usando FileWriteStruct(). Trata-se de estruturas simples que não contêm cordas, arrays dinâmicos,funções virtuais, bem como apontadores para objectos e funções.

E isto significa que tem de os inventar e testar. Mas eu escrevi a direcção. A implementação precisa de ser pensada.

 
Artyom Trishkin:

Não, ainda não haverá exemplos - eu próprio ainda não o fiz, e quando o fizer, irei descrevê-lo nos artigos. E não será em breve. O facto é que apenas as estruturas POD podem ser escritas em ficheiro usando FileWriteStruct(). Ou seja, estruturas simples que não contêm cordas, arrays dinâmicos, funções virtuais, bem como apontadores para objectos e funções.

E isto significa que temos de o inventar e testar. Mas eu escrevi a direcção. A implementação deve ser pensada.

Acontece que não importa como se olha para ela, a tarefa não pode ser resolvida. Afinal, o exemplo de Sergei tem três matrizes dinâmicas no seu interior. Não importa como a estrutura está disposta na estrutura, ela continuará a ser uma matriz dinâmica.

Mas se se criar um conjunto de estruturas, o problema é resolvido escrevendo o conjunto. FileWriteArray(). Isto já foi testado e a documentação afirma claramente sobre a escrita de um conjunto de estruturas.

 
Alexey Viktorov:

Mas lê a matriz do princípio ao fim. Como é que se divide em 3 partes? Como se escreve uma estrutura e se consegue escrever uma matriz para o mesmo ficheiro? Sou autodidacta, não sei muitas coisas, mas o facto de que são formatos de dados diferentes, de alguma forma suspeito.

Admito que se pode escapar, abrindo um ficheiro para escrever uma vez e enfiando nele três arrays, mas não será possível lê-lo em partes como essa.

Num ficheiro binário, pode escrever quaisquer estruturas, arrays, mesmo variáveis únicas, tudo num só ficheiro.

MAS, ao ler, deve ler os dados na mesma ordem.

tudo irá funcionar.

não tenham visto o arquivo despejado, ao escrever com FileWriteArray() , muito provavelmente, o tamanho da matriz será escrito nos primeiros bytes - mas é mais fácil fazer um roteiro de teste, há uma dúzia de linhas de código ;)

 
Alexey Viktorov:

Acontece que, independentemente da forma como se olhe para ele, o problema é insolúvel. Afinal de contas, no exemplo de Sergei existem três matrizes dinâmicas no interior. Não importa como se constrói a estrutura na estrutura, esta continuará a ser uma matriz dinâmica.

E se criar um conjunto de estruturas, irá resolver o problema escrevendo o conjunto. FileWriteArray(). Isto já foi testado e está claramente declarado na documentação sobre a escrita de uma série de estruturas.

Uma série de estruturas é armazenada, mas... se houvesse cordas, elas podem ser embaladas em uchar array dentro da estrutura, o que é feito com sucesso. Mas não há forma de o dobro da matriz poder caber na matriz uchar. Além disso, é dinâmico. E salvar as três arrays separadamente em ficheiros e depois empurrá-los para a estrutura desempacotada do ficheiro... Ainda não o experimentei. Ainda não pensei no assunto e não sei.

 
Igor Makanu:

pode escrever quaisquer estruturas, matrizes, mesmo variáveis individuais num ficheiro binário - tudo no mesmo ficheiro

MAS ao ler, tem de ler os dados na mesma ordem.

tudo vai funcionar

não tenham visto o arquivo despejado quando escrevendo com FileWriteArray() , muito provavelmente, o tamanho da matriz será escrito nos primeiros bytes - mas é mais fácil fazer um roteiro de teste, há uma dúzia de linhas de código ;)

Não sei onde começou a ler sobre este problema, deixe-me lembrar-lhe apenas no caso de: tem de escrever uma estrutura contendo três matrizes dinâmicas num ficheiro. Depois tive uma pergunta sobre o ficheiro não ter sido lido correctamente.

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

FAQ de Iniciantes MQL5 MT5 MetaTrader 5

Sergey Tabolin, 2020.03.24 18:02

Estou a perguntar ))))

Tentei fazê-lo "à minha maneira".

A primeira estrutura e 3 matrizes lêem bem (desde que os receptores das matrizes não sejam dinâmicos, caso contrário todos os dados escritos após a estrutura serem lidos na primeira matriz).

No entanto, se houver mais entradas, então

   // Проверка
   double   rdata_1[6];
   double   rdata_2[6];
   double   rdata_3[6];
   
   filehandle = FileOpen(filename,FILE_READ|FILE_COMMON|FILE_BIN);
   if(filehandle != INVALID_HANDLE)
   {
      while(!FileIsEnding(filehandle))
      {
         FileReadStruct(filehandle,rfann);
         FileReadArray(filehandle,rdata_1);
         FileReadArray(filehandle,rdata_2);
         FileReadArray(filehandle,rdata_3);
         Print("++++++++++++++++++++++++++++++");
         Print("Структура");
         Print(rfann.v_main_up+"|"+rfann.v_main_dn+"|"+rfann.v_add_up+"|"+rfann.v_add_dn+"|"+rfann.answer);
         Print("Массивы");
         Print("--- 1");
         ArrayPrint(rdata_1);
         Print("--- 2");
         ArrayPrint(rdata_2);
         Print("--- 3");
         ArrayPrint(rdata_3);
      }
   }

dá um inferno de muita coisa.

Структура
4.0|-1.0|2.8|-0.7|1
Массивы
--- 1
 1.00000  0.33225 -0.76202 -0.93263 -1.00000 -0.79174
--- 2
-0.14603  0.89562  0.91407  0.93450  0.89481  0.89829
--- 3
 0.89564  0.89217 -0.91174 -0.86623 -1.00000 -0.07680
++++++++++++++++++++++++++++++
Структура
1.839259944929932 e+277|-nan|5.295254096666168 e-315|3.0|-618173028
Массивы
--- 1
 2.10000 -2.00000 -1.40000 -0.85098 -1.00000 -0.79900
--- 2
-0.30490  0.47926  1.00000  0.70827  0.84163  0.84134
--- 3
 0.83925  0.84173  0.84760  0.84678  0.80368 -0.00063
++++++++++++++++++++++++++++++
Структура
9.384173261527221 e-276|5.298850499315376 e-315|2.955277867691187 e+299|-9.638234784517503 e-243|-1705145188
Массивы
--- 1
+0.00000 +0.00000  4.00000  2.80000  0.00000  0.00000
--- 2
 1.00000  0.22097 -0.37383 -0.73115 -0.81752 -1.00000
--- 3
-0.87753  0.46919  0.59706  0.76223  0.82610  0.84312
++++++++++++++++++++++++++++++

Portanto, estou a pensar: como é possível ler a estrutura e três matrizes de um ficheiro, que não se sabe como foi escrito.

É por isso que disse que sou autodidacta e não sei muito, mas não se pode ler em partes.

E compreendo que existem opções para adicionar ao ficheiro .bin tudo, mas para o ler é necessário saber o que está escrito em que ordem. E é possível que não por meio de mql.

 

Não percebo nada disto...

      FileSeek(filehandle,0,FILE_END);

'FILE_END' - cannot convert enum                        282     31
'FILE_END' - improper enumerator cannot be used         282     31

O que há de errado?

 
Alexey Viktorov:

Portanto, estou a pensar: como é possível ler uma estrutura e três matrizes de um ficheiro, que não se sabe como foi escrito.

é o que estou a escrever, é mais fácil de verificar, dentro de 10 minutos.... verificado, FileWriteArray() não escreve o tamanho do array no cabeçalho ou no primeiro byte, significa que deve escrever estes valores você mesmo

#property copyright "IgorM"
#property link      "https://www.mql5.com/ru/users/igorm"

struct SMystruct
{
   double            d_arr[];
   int               i_arr[];
   uchar             c_arr[];
   int               a;
   double            b;
};

//+------------------------------------------------------------------+
void OnStart()
{
   SMystruct mstruct;
   ArrayResize(mstruct.d_arr,5);    ArrayInitialize(mstruct.d_arr,3.1415926);
   ArrayResize(mstruct.i_arr,3);    ArrayInitialize(mstruct.i_arr,1234567890);
   ArrayResize(mstruct.c_arr,7);    ArrayInitialize(mstruct.c_arr,127);
   mstruct.a = 666;
   mstruct.b = 123.123;
//---  
   if(!SaveMStructToFile("mfile.bin",mstruct)) return;
   SMystruct read_struct;
   if(!LoadMStructInFile("mfile.bin",read_struct)) return;
   Print("1. d_arr");
   ArrayPrint(read_struct.d_arr);
   Print("2. i_arr");
   ArrayPrint(read_struct.i_arr);
   Print("2. c_arr");
   ArrayPrint(read_struct.c_arr);
   printf("mstruct.a = %i , mstruct.b = %f",read_struct.a , read_struct.b);
   
}
//+------------------------------------------------------------------+
bool SaveMStructToFile(const string fname,const SMystruct &data)
{
   int h = FileOpen(fname,FILE_WRITE | FILE_BIN | FILE_COMMON);
   if(h<0) { Print("Write IO Err #",GetLastError()); return(false); }
   FileWriteInteger(h,ArraySize(data.d_arr));   FileWriteArray(h,data.d_arr);
   FileWriteInteger(h,ArraySize(data.i_arr));   FileWriteArray(h,data.i_arr);
   FileWriteInteger(h,ArraySize(data.c_arr));   FileWriteArray(h,data.c_arr);
   FileWriteInteger(h,data.a);
   FileWriteDouble(h,data.b);
   FileClose(h);  
   return(true);
}

bool LoadMStructInFile(const string fname,SMystruct &data)
{
   int h = FileOpen(fname,FILE_READ | FILE_BIN | FILE_COMMON);
   if(h<0) { Print("Write IO Err #",GetLastError()); return(false); } 
   int amount = ArrayResize(data.d_arr,(int)FileReadInteger(h));     FileReadArray(h,data.d_arr,0,amount);
       amount = ArrayResize(data.i_arr,(int)FileReadInteger(h));     FileReadArray(h,data.i_arr,0,amount);
       amount = ArrayResize(data.c_arr,(int)FileReadInteger(h));     FileReadArray(h,data.c_arr,0,amount);
   data.a = FileReadInteger(h);
   data.b = FileReadDouble(h);
   FileClose(h); 
   return(true);
}

2020.03.25 10:18:36.058 tst (EURUSD,H1) 1. d_arr

2020.03.25 10:18:36.058 tst (EURUSD,H1) 3.14159 3.14159 3.14159 3.14159 3.14159

2020.03.25 10:18:36.058 tst (EURUSD,H1) 2. i_arr

2020.03.25 10:18:36.058 tst (EURUSD,H1) 1234567890 1234567890

2020.03.25 10:18:36.058 tst (EURUSD,H1) 2. c_arr

2020.03.25 10:18:36.058 tst (EURUSD,H1) 127 127 127 127 127 127

2020.03.25 10:18:36.058 tst (EURUSD,H1) mstruct.a = 666 , mstruct.b = 123.123000

ou seja, se as dimensões do array são dinâmicas, significa que nós próprios escrevemos as dimensões do array ao escrever, e ao ler, lemos o valor do tamanho do array a partir do ficheiro e definimos as dimensões dos array da estrutura

no meu exemplo 2 estruturas - uma foi rubricada e escrita, a segunda foi lida, rubricada a partir de dados do ficheiro
1...119411951196119711981199120012011202120312041205120612071208...1503
Novo comentário