Na MQL5 há sempre espaço para uma exploração! ;) - página 8

Novo comentário
 
estás a sujar a água num balde.
Apontadores para variáveis, para funções, tomando endereço por referência são todas as restrições MQL.
Nem sequer é algo que não esteja previsto pela sintaxe, é uma proibição do manuseamento da memória.
Mesmo o ponteiro vazio* não é um ponteiro no sentido C habitual.
É um objecto para trabalhar com objectos de classe para evitar que sejam copiados.
A mesma referência & não é uma tomada de endereço, mas um especificador para o compilador passar um objecto sem o copiar para a pilha.
Quer escrever em Sirac, escrever em Sirac e importar dll, tudo bem.

Se está realmente ansioso por apanhar o jeito e não pode ignorar a dll, então importar da dll nativa não é um grande pecado, e o seu produto MQL não perderá valor com isto.

Para não fazer alarido, por exemplo, pode usar apenas um ponteiro de 4 bytes e importar memórias para trabalhar com a memória dentro de um processo terminal.

#importar "msvcrt.dll"
int memcpy(short&,short&,int);
int memcpy(int&,int&,int);
int memcpy(double&,double&,int);
int memcpy(string& s,string& int);
#importância

algum tipo de classe de invólucro:

TPtr estrutural
{
int destinatário;
TPtr():addr(0){}
TPtr(const TPtr& r):addr(r.addr){}
template<typename _T> TPtr operador =(_T& r) {
addr = memcpy(r,r,0);
devolver isto;
}
};


e um exemplo de utilização:

string sval = "123";
bval curto = 123;
int ival = 123;
dval duplo = 123;

TPtr p = sval;
int ptrs = p.addr;
p = bval;
int ptrb = p.addr;
p = ival;
int ptri = p.addr;
p = dval;
int ptrd = p.addr;

Desta forma, pode manipular a memória como quiser. Não são os habituais pólos em C, mas mesmo assim

Como pode ser útil?
Bem, por exemplo, pode utilizar a função de importação GlobalAlloc, para que não precise de utilizar variáveis globais para transferir dados entre módulos.
GlobalAlloc atribui memória ao processo, que não está associada a uma pilha ou estática interna virtual para o trabalho de uma coruja ou de um induzido.
Pode colocar nela matrizes de qualquer tamanho e utilizar memórias para indexação.

Exemplo de importação:

#define HANDLE int
#define LPVOID int

#importar "kernel32.dll"
HANDLE GlobalAlloc(uint flags, uint cnt);
LPVOID GlobalLock(HANDLE hmem);
int GlobalUnlock(HANDLE hmem);
HANDLE GlobalFree(HANDLE hmem);
#importar "ntdll.dll".
// GetLastError já existe em MT, pelo que a sua utilização é da WinAPI:
int RtlGetLastWin32Error();
#importância


Um exemplo de utilização:

// coruja N1, prepare a sua gama de tarifas

Taxas de Mql[123];
// aqui enchemos
HANDLE memid = GlobalAlloc(GMEM_MOVEABLE, 123*sizeof(MqlRates));
LPVOID ptr=GlobalLock(memid);
memcpy(ptr,rates[0].time, 123*sizeof(MqlRates)); // aqui, a fim de compilar, deve-se fazer um protótipo int memcpy(int&,const datetime&,int)
GlobalUnlock(memid);
// enviar um descritor de memória
EventChartCustom(CID, MY_SEND_DATA, memid, 0, "");

// coruja 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);
Taxas de Mql[123];
// tem taxas
memcpy(rates[0].time,ptr,123*sizeof(MqlRates)); // aqui está o protótipo int memcpy(datetime&,const int&,int)
GlobalUnlock(memid);
GlobalFree(memid);
}
}

É tudo... nada de tubos, ficheiros externos, importação de sobras de dlls.
Acabei de apressar uma pequena amostra com grandes possibilidades, mas a minha mente não conhece limites.
Sim, em relação à GlobalAlloc continuo a sugerir a utilização de GMEM_MOVEABLE, com fechadura e capa de memória para obter ponteiro para operação específica, devolva-o.
Se utilizar memória global fixa, a N número de descritores abertos pode ocorrer fragmentação...
é o que o núcleo do SO quiser, dependendo da carga.
Boa sorte, hackers )))
 
alexsis78:

Para não ser vago, por exemplo, pode usar apenas um ponteiro de 4 bytes e importar memórias para trabalhar com a memória dentro do processo terminal
tem um pouco o ramo errado.
 

Há um livro antigo de Henry Warren, "Algorithmic tricks for programmers", que está cheio de tais truques. No entanto, a maioria dos exemplos não funcionará em MQL devido à falta de indicadores C++.

Vou tentar encontrar algo divertido.

 
Não encontrará a semelhança do meu exemplo em C ))) Primeiro é MQL, segundo é uma alternativa para a sintaxe do ponteiro C.

Um pouco mais de esclarecimento para aqueles que sabem mais.

Em C:
int var = 0; // declarar variável var
int* ptr = &var; // obter ponteiro para variável var
int var2 = *ptr; // copiar valor por ponteiro para var2

Em MQL:
#importar "msvcrt".dll"
uint memcpy(int& destino, const int& fonte, int cnt); // protótipo de memcpy para obter o endereço de destino variável
uint memcpy(int& destino, uint ptr, int cnt); // o protótipo de memória a copiar do endereço ptr
// o compilador irá substituir um dos dois protótipos por diferença de tipo do segundo argumento
// tomemos um tipo de ponteiro, por exemplo uint
#import

int var = 0;
uint ptr = memcpy(var,var,0); // obtenhamos um ponteiro ptr para a variável var (aqui memcpy não copia nada mas devolve o endereço var)
int var2
memcpy(var2, ptr, 4); // copy 4 bytes ou sizeof(int) do ponteiro ptr à variável var2 (o segundo protótipo de obras de memcpy)

Espero que considere o método útil )))
 
alexsis78:
Não encontrará a similaridade do meu exemplo em C))) Em primeiro lugar, é MQL, em segundo lugar, contornar a sintaxe dos ponteiros C.
Espero que a considere útil ))))

pessoas, não escrevam por escrever algo.

Todas estas variantes com memcpy são mastigadas há vários anos e não são adequadas para este tópico.

 
o_O:

Pessoas, não escrevam por escrever algo.

Todas estas opções de memórias foram mastigadas há anos e não são adequadas para este tópico.

Concordo, além disso, que a variante sem aritmética de ponteiro foi descrita, ou seja, defeituosa. Não são realmente necessários em C#, não há indicações. Não é seguro mas é apenas para uso pessoal e haverá muitas restrições como a proibição de instalação através da rede e assim por diante.
 

Queria colocá-lo na base de código, mas depois mudei de ideias:

Usando MQL5 na tarefa Kaggle, Digit Recognizer

Digit Recognizer | Kaggle
  • www.kaggle.com
Kaggle is your home for data science. Learn new skills, build your career, collaborate with other data scientists, and compete in world-class machine learning challenges.
Arquivos anexados:
sampleMNIST.mq5  25 kb
 
o_O:

Pessoas, não escrevam apenas para escrever alguma coisa.

Todas estas opções de memórias foram mastigadas durante anos e não são adequadas para este tópico.

Porque é "inapropriado"?

Esqueci-me onde estava e não o consegui encontrar...

A propósito, eu consideraria guardar um ponteiro para uma matriz sem chamar a DLLs externas uma proeza. Não quero ter de confirmar cada vez que inicio indicadores que concordo com a importação de funções da DLL.

 
George Merts:

Porque é que "não é adequado"?

Já esqueci onde estava e não consegui encontrá-lo...

A propósito, consideraria uma proeza salvar um ponteiro para uma matriz sem envolver DLLs externas. Não quero ter de confirmar cada vez que inicio indicadores que concordo em importar funções de uma DLL

Embrulhe a matriz numa classe, pode fazer-lhe pseudo-pontos de MQL com novos
 
Alexey Volchanskiy:
Embrulhe a matriz numa classe e pode fazer-lhe pseudo-pontos de MQL com novos

Alexey, deve também dizer-me como embrulhar arrays, emitidos pela função OnCalculate(), numa classe - neste caso, não pode passar sem copiar apontadores.

Neste momento, estou apenas a copiar dados para a minha colecção, e depois estou a puxar um ponteiro para este objecto. Mas isso iria obter alguma cópia extra, o que, como vejo, acrescenta um "peso" considerável com carraças frequentes e um grande número de gráficos. Quero ver-me livre desta cópia. Mas, excepto para uma muleta via DLL (padrão ou auto-escrita), não há nada que eu possa sugerir.

No Service Desk, eles continuam a empurrar-me de volta dizendo "o objecto pode ser apagado". Mas estas são as suas próprias matrizes! Quando digo que posso criar um objecto e depois removê-lo e o ponteiro se torna inválido - eles respondem que "sou eu que serei responsável por isto". Esta é uma "dupla moralidade" em acção aqui.

Não quero saber da DLL - mas tais indicadores requerem confirmação constante quando em funcionamento - que incómodo...

123456789
Novo comentário