Preguntas de los principiantes MQL5 MT5 MetaTrader 5 - página 1201

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

Escribo todo en un solo archivo. Escribir, y luego leer, varias estructuras en el mismo archivo va bien.

Pero lee la matriz de principio a fin. ¿Cómo se divide en 3 partes? ¿Cómo has escrito una estructura y has conseguido escribir un array en el mismo archivo? Soy autodidacta, no sé mucho, pero el hecho de que sean formatos de datos diferentes, de alguna manera lo sospecho.

Admito que puedes conseguir abrir el archivo para escribir una vez y meter tres matrices, pero no puedes leerlo por partes así.

 
Alexey Viktorov:

Pero lee la matriz de principio a fin. ¿Cómo se divide en 3 partes? ¿Cómo se escribe una estructura y se consigue escribir un array en el mismo archivo? Soy autodidacta, no sé mucho, pero el hecho de que sean formatos de datos diferentes, de alguna manera sospecho.

Admito que puedo salirme con la mía abriendo un archivo para escribir una vez y meter tres matrices en él, pero no puedo leerlo tan fácilmente por partes.

Digo yo, si escribes en el mismo fichero sólo 1 estructura y 3 arrays, entonces puedes leerlos desde ahí (suponiendo que para leer los arrays tienes que especificar el tamaño de cada uno). Pero el truco de escribir y luego leer varias secuencias de este tipo no me funcionó. Quizá tenga que mover el puntero, pero ya está tenso...

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

Ya te dije que si escribes sólo 1 estructura y 3 arrays en un archivo, luego puedes leerlos desde ahí (siempre que tengas que especificar el tamaño de cada uno de ellos para leer los arrays). Pero el truco de escribir y luego leer varias secuencias de este tipo no me funcionó. Tal vez tenga que mover el puntero, pero eso es un poco engorroso...

¿Cómo se tensa? ¿No hay suficiente potencia? ¿Y cómo puedes estar seguro de que la escritura fue exitosa y cómo lo asumes si la lectura falló? Que yo sepa, no se puede mirar un archivo .bin con los ojos.

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

Artyom, ¿puedes darme un ejemplo? Teniendo en cuenta que el tamaño de las matrices es dinámico.

No, todavía no habrá ejemplos: aún no lo he hecho yo mismo, y cuando lo haga, lo describiré en mis artículos. Y no será pronto. El hecho es que sólo se pueden escribir estructuras POD en un archivo utilizando FileWriteStruct(). Es decir, estructuras simples que no contienen cadenas, matrices dinámicas,funciones virtuales, así como punteros a objetos y funciones.

Y esto significa que hay que inventarlos y probarlos. Pero he escrito la dirección. Hay que pensar en la aplicación.

 
Artyom Trishkin:

No, aún no habrá ejemplos: todavía no lo he hecho yo, y cuando lo haga, lo describiré en artículos. Y no será pronto. El hecho es que sólo las estructuras POD pueden escribirse en un archivo utilizando FileWriteStruct(). Es decir, estructuras simples que no contienen cadenas, matrices dinámicas, funciones virtuales, así como punteros a objetos y funciones.

Y esto significa que tenemos que inventarlo y probarlo. Pero he escrito la dirección. Hay que reflexionar sobre la aplicación.

Resulta que, se mire como se mire, la tarea no se puede resolver. Después de todo, el ejemplo de Sergei tiene tres matrices dinámicas en su interior. No importa cómo se disponga la estructura en la estructura, seguirá siendo una matriz dinámica.

Pero si se crea un array de estructuras, el problema se resuelve escribiendo el array. FileWriteArray(). Esto ya ha sido probado y la documentación dice claramente sobre la escritura de un array de estructuras.

 
Alexey Viktorov:

Pero lee la matriz de principio a fin. ¿Cómo se divide en 3 partes? ¿Cómo se escribe una estructura y se consigue escribir un array en el mismo archivo? Soy autodidacta, no sé muchas cosas, pero el hecho de que sean formatos de datos diferentes, de alguna manera lo sospecho.

Lo admito, puedes salirte con la tuya, abrir un archivo para escribir una vez y meter tres arrays en él, pero no podrás leerlo por partes así.

En un archivo binario, puede escribir cualquier estructura, matriz, incluso variables individuales, todo en un archivo.

PERO, al leer, debe leer los datos en el mismo orden.

todo funcionará.

no he visto el volcado del archivo al escribir con FileWriteArray() , lo más probable es que el tamaño del array se escriba en los primeros bytes - pero es más fácil hacer un script de prueba, hay una docena de líneas de código ;)

 
Alexey Viktorov:

Resulta que, se mire como se mire, el problema es irresoluble. Después de todo, en el ejemplo de Sergei hay tres matrices dinámicas en su interior. No importa cómo se construya la estructura en la estructura, seguirá siendo una matriz dinámica.

Y si creas un array de estructuras, resolverás el problema escribiendo el array. FileWriteArray(). Esto ya ha sido probado y está claramente indicado en la documentación sobre la escritura de un array de estructuras.

Se almacena un array de estructuras, pero... si hubiera cadenas, se pueden empaquetar en un array uchar dentro de la estructura, lo que se hace con éxito. Pero no hay manera de que un array double entre en un array uchar. Además, es dinámico. Y guardando las tres matrices por separado en archivos y luego metiéndolas en la estructura desempaquetada del archivo... No lo he probado. No he pensado en ello y no lo sé.

 
Igor Makanu:

puede escribir cualquier estructura, matriz, incluso variables individuales en un archivo binario - todo en el mismo archivo

PERO al leer, hay que leer los datos en el mismo orden.

todo funcionará

no he visto el volcado del archivo al escribir con FileWriteArray() , lo más probable es que el tamaño del array se escriba en los primeros bytes - pero es más fácil hacer un script de prueba, hay una docena de líneas de código ;)

No sé dónde empezaste a leer sobre este problema, déjame recordártelo por si acaso: tienes que escribir una estructura que contiene tres arrays dinámicos en un archivo. Entonces tuve una pregunta sobre el archivo que no se lee correctamente.

Foro sobre comercio, sistemas de comercio automatizados y pruebas de estrategia

FAQ de principiantes MQL5 MT5 MetaTrader 5

Sergey Tabolin, 2020.03.24 18:02

Le pido a ))))

He intentado hacerlo "a mi manera".

La primera estructura y los 3 arrays se leen bien (siempre que los receptores de los arrays no sean dinámicos, de lo contrario todos los datos escritos después de la estructura se leen en el primer array).

Sin embargo, si hay más entradas, entonces

   // Проверка
   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);
      }
   }

da un montón de...

Структура
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
++++++++++++++++++++++++++++++

Así que estoy pensando: ¿cómo es posible leer la estructura y tres matrices de un archivo, que no se sabe cómo fue escrito.

Por eso he dicho que soy autodidacta y no sé mucho, pero no se puede leer por partes.

Y entiendo que hay opciones para añadir al archivo .bin todo, pero para leerlo hay que saber qué se escribe y en qué orden. Y es posible que no por medio de mql.

 

No entiendo esto en absoluto...

      FileSeek(filehandle,0,FILE_END);

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

¿Qué tiene de malo?

 
Alexey Viktorov:

Entonces pienso: cómo es posible leer una estructura y tres arrays de un archivo, que no se sabe cómo fue escrito.

eso es lo que escribo, es más fácil de comprobar, en 10 minutos.... comprobado, FileWriteArray() no escribe el tamaño de la matriz en la cabecera o el primer byte, significa que debes escribir estos valores tú mismo

#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

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

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

es decir, si las dimensiones de las matrices son dinámicas, significa que escribimos las dimensiones de la propia matriz al escribir, y al leer, leemos el valor del tamaño de la matriz desde el archivo y establecemos las dimensiones de las matrices de la estructura

en mi ejemplo 2 estructuras - una fue inicializada y escrita, la segunda fue leída, inicializada desde los datos del archivo
1...119411951196119711981199120012011202120312041205120612071208...1503
Nuevo comentario