¡En MQL5 siempre hay espacio para un exploit ! ;) - página 8
Está perdiendo oportunidades comerciales:
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Registro
Entrada
Usted acepta la política del sitio web y las condiciones de uso
Si no tiene cuenta de usuario, regístrese
Los punteros a variables, a funciones, la toma de direcciones por referencia son todas restricciones de MQL.
Ni siquiera es algo que no esté previsto en la sintaxis, es una prohibición de manejar la memoria.
Incluso el puntero void* no es un puntero en el sentido habitual de C.
Es un objeto para trabajar con objetos de clase para evitar que se copien.
La misma referencia & no es una toma de dirección, sino un especificador para que el compilador pase un objeto sin copiarlo en la pila.
Si quieres escribir en Syakh, escribe en Syakh e importa dll, está bien.
Si realmente te pica el gusanillo y no puedes foregn dll, entonces importar desde dll nativas no es un gran pecado, y tu producto MQL no perderá valor por ello.
Para no hacer un escándalo, por ejemplo, puedes usar sólo un puntero de 4 bytes e importar memcpy para trabajar con la memoria dentro de un proceso de la terminal.
algún tipo de clase envolvente:
De este modo, puedes manipular la memoria como quieras... No son los habituales punteros C, pero aún así
¿Cómo puede ser útil?
Bueno, por ejemplo, puedes usar la función de importación GlobalAlloc, para no tener que usar variables globales para transferir datos entre módulos.
GlobalAlloc asigna memoria al proceso, que no está asociada a un heap o virtual estático interno para el trabajo de un búho o un inducido.
Puedes colocar arrays de cualquier tamaño en él y utilizar memcpy para la indexación.
Ejemplo de importación:
#define HANDLE int
#define LPVOID int
Un ejemplo de uso:
// búho N1, prepara tu matriz de tarifas
Tasas MqlRates[123];
// aquí llenamos
HANDLE memid = GlobalAlloc(GMEM_MOVEABLE, 123*sizeof(MqlRates));
LPVOID ptr=GlobalLock(memid);
memcpy(ptr,rates[0].time, 123*sizeof(MqlRates)); // aquí, para compilar, hay que hacer el prototipo int memcpy(int&,const datetime&,int)
GlobalUnlock(memid);
// enviar un descriptor de memoria
EventChartCustom(CID, MY_SEND_DATA, memid, 0, "");
// búho N2
void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
{
if( id == CHARTEVENT_CUSTOM+MY_SEND_DATA )
{
LPVOID ptr = GlobalLock((HANDLE)lparam);
Tasas MqlRates[123];
// tiene tarifas
memcpy(rates[0].time,ptr,123*sizeof(MqlRates)); // aquí está el prototipo int memcpy(datetime&,const int&,int)
GlobalUnlock(memid);
GlobalFree(memid);
}
}
Eso es todo... sin tuberías, archivos externos, importación de dlls sobrantes.
Sólo he apurado una pequeña muestra con grandes posibilidades, pero mi mente no tiene límites.
Sí, con respecto a GlobalAlloc sigo sugiriendo utilizar GMEM_MOVEABLE, con bloqueo y anloak de memoria para obtener puntero para una operación específica, devolverlo.
Si se utiliza una memoria global fija, a partir de un número N de descriptores abiertos puede producirse una fragmentación...
es lo que el núcleo del sistema operativo quiera en función de la carga.
Buena suerte, hackers )))
Para no ser imprecisos, por ejemplo, se puede utilizar sólo un puntero de 4 bytes e importar memcpy para trabajar con la memoria dentro del proceso de la terminal
Hay un viejo libro de Henry Warren, "Algorithmic tricks for programmers", que está lleno de estos trucos. Sin embargo, la mayoría de los ejemplos no funcionarán en MQL debido a la falta de punteros de C++.
Intentaré encontrar algo divertido.
Un poco más de aclaración para los que saben más.
En C:
int var = 0; // declarar la variable var
int* ptr = &var; // obtener el puntero a la variable var
int var2 = *ptr; // copiar el valor del puntero a var en var2
En MQL:
#import "msvcrt.dll"
uint memcpy(int& destination, const int& source, int cnt); // prototipo de memcpy para obtener la dirección de la variable destino
uint memcpy(int& destination, uint ptr, int cnt); // el prototipo de memcpy para copiar desde la dirección ptr
// el compilador sustituirá uno de los dos prototipos por diferencia de tipo del segundo argumento
// tomemos un tipo de puntero, por ejemplo uint
#import
int var = 0;
uint ptr = memcpy(var,var,0); // obtenemos un puntero ptr a la variable var (aquí memcpy no copia nada sino que devuelve la dirección var)
int var2
memcpy(var2, ptr, 4); // copiar 4 bytes o sizeof(int) desde el puntero ptr a la variable var2 (el segundo prototipo de memcpy funciona)
Espero que el método os sea útil )))
No encontrarás la similitud de mi ejemplo en C))) En primer lugar, se trata de MQL, y en segundo lugar, de evitar la sintaxis de los punteros en C.
Espero que le resulte útil ))))
gente, no escriba sólo por escribir algo.
Todas estas variantes con memcpy están masticadas hace varios años y no son adecuadas para este tema.
Gente, no escriban por escribir algo.
Todas estas opciones de memcpy fueron masticadas hace años y no son adecuadas para este tema.
Quería ponerlo en el código base, pero luego cambié de opinión:
Uso de MQL5 en Kaggle, tarea de reconocimiento de dígitos
Gente, no escriban sólo por escribir algo.
Todas estas opciones de memcpy han sido masticadas durante años y no son adecuadas para este tema.
¿Por qué es "inapropiado"?
He olvidado dónde estaba y no he podido encontrarlo...
Por cierto, yo consideraría una hazaña guardar un puntero a un array sin llamar a DLLs externas. No quiero tener que confirmar cada vez que inicie los indicadores que estoy de acuerdo en importar funciones de la DLL.
¿Por qué "no es adecuado"?
Ya he olvidado dónde estaba y no he podido encontrarlo...
Por cierto, yo consideraría una hazaña guardar un puntero a un array sin involucrar DLLs externas. No quiero tener que confirmar cada vez que inicio los indicadores que estoy de acuerdo en importar funciones de una DLL
Envuelve el array en una clase y podrás hacer pseudoapuntadores MQL a él con new
Alexey, también deberías decirme cómo envolver arrays, emitidos por la función OnCalculate(), en una clase - en este caso no se puede hacer sin copiar punteros.
Por el momento, sólo estoy copiando datos en mi clase-array, y luego estoy sacando un puntero a este objeto. Pero eso supondría una copia extra que, por lo que veo, añade una "pesadez" bastante notable con los frecuentes ticks y el gran número de gráficos. Quiero deshacerme de esta copia. Pero, salvo una muleta vía DLL (estándar o autoescrita), no hay nada que pueda sugerir.
En el Service Desk, me devuelven el mensaje de que "el objeto puede ser eliminado". ¡Pero son sus propias matrices! Cuando les digo que puedo crear un objeto y luego eliminarlo y el puntero dejará de ser válido, me responden que "soy yo el responsable". Se trata de una "doble moral".
No me importa la DLL - pero tales indicadores requieren una confirmación constante cuando se ejecutan - que molestia...