Dans MQL5, il y a toujours de la place pour un exploit ! ;) - page 2

Nouveau commentaire
 
sergeev:

Et donc il y a la question numéro un.

Comment importer des fonctions de dlls 32 bits comme user32.dll etc. dans une application 64 ? Ou bien existe-t-il des copies pour eux dans le système avec ce nom et un espace OOP est créé ?

Tout d'abord, les systèmes x64 ont un lancement émulé des programmes x86. La question est de savoir comment exécuter des programmes x64 en x86 ?
 
Urain:
Tout d'abord, les systèmes x64 ont un lancement émulé des programmes x86. La question est de savoir comment exécuter des programmes x64 en x86 ?

Peut-être que la question n'est pas du tout liée au terminal mais à une compilation délicate de ces mêmes DLLs ?

Les DLL sont alimentées par l'API Windows, par exemple user32, kernel32, winmm, wininet dans le terminal 32/64 bit.

La solution du problème semble se trouver ailleurs.

 
Urain:
La question est de savoir comment exécuter des programmes x64 en x86 ?
Cela ne fonctionnera certainement pas. Le processeur x86 ne peut pas exécuter d'instructions 64 bits.
sergeev:

Peut-être que la question n'est pas du tout liée au terminal, mais à une compilation délicate de ces mêmes DLLs ?

Par exemple, user32, kernel32, winmm, wininet fonctionnent dans un terminal 32/64 bits.

La solution à ce problème semble se trouver ailleurs.

Donc, théoriquement, vous pouvez faire fonctionner des DLL 32 bits ici et là.

Il est peut-être temps d'appeler les développeurs.

Il existe peut-être des méthodes de compilation plus astucieuses // J'ai cessé de travailler avec une DLL 32 bits compilée de manière "naïve" sur x64. Quoi qu'il en soit, il y a des précédents qui "existent" (c).

Par exemple, user32, kernel32, winmm, wininet dans le terminal 32/64 bits.

 
MetaDriver:

Alors faites-le dans cette analogie... pas de problème !... :-))

Je vais regarder. ;)

//+------------------------------------------------------------------+
class Cdouble
{
public:
        double                  v;
        void    operator=       (double d) {v=d;}
};
//+------------------------------------------------------------------+
class C1Xdouble
{
        Cdouble                 v[];
public:
        
                                C1Xdouble() {}
                                C1Xdouble(int s) {ArrayResize(v,s);}
                               ~C1Xdouble(){ ArrayFree(v);}
        double operator[]       (int x) {return(v[x].v);}
        Cdouble *operator[]    (long x){return(GetPointer(v[(int)x]));}
        int                     Resize(int s){ return(ArrayResize(v,s));}
};
//+------------------------------------------------------------------+
class C2Xdouble
{
        C1Xdouble               v[];
public:
                                C2Xdouble() {}
                                C2Xdouble(int s1,int s2);
                               ~C2Xdouble(){ ArrayFree(v);}
        C1Xdouble *operator[]   (int x) { return(GetPointer(v[x]));}
};
C2Xdouble::C2Xdouble(int s1,int s2)
{
        ArrayResize(v,s1);
        for(int i=0; i<s1; i++) v[i].Resize(s2);
}
//+------------------------------------------------------------------+
La façon la plus simple de l'appliquer à votre cas.
 
Yurich:
La version la plus simple pour votre cas.

Eh bien, pour le cas le plus simple, le crédit. "Je vous écris" :)

De mémoire, mais avec parcimonie, en comparaison. 

    C2Xdouble  X(1000,1000);
    Print("X(100,100).SizeOF() = ",X.SizeOf()); 
// добавил в ваши классы вычисление размера
-----
    C2DMagicArray  MA(1000,1000);
    Print("MA(100,100).SizeOF() = ",sizeof(MA)+MA.SizeOf()); 
// это мой. у меня MA.SizeOf() возвращает только размер чистого буфера, поэтому по честному добавил размер класса. :)

résultat :

2012.05.23 12:59:05     CXDouble (AUDNZD,M1)    MA(100,100).SizeOF() = 4000112
2012.05.23 12:59:05     CXDouble (AUDNZD,M1)    X(100,100).SizeOF() = 24068068

La différence est de 6 fois. En tenant compte du fait que j'ai un tampon flottant - 3 fois. // Vous avez également un vol de mémoire implicite - votre tableau système de descripteurs de classe (dans cet exemple) est de 1000*1000+1000, alors que le mien est de 1 ( !).

La vitesse est presque la même.

Allez-vous rétrécir ? ;)

--

J'ai menti, vos sous-classes sont toutes statiques, donc le vol implicite est un peu exagéré. Grattez ça. :)

 
MetaDriver:

Il est peut-être temps d'appeler les développeurs.
En bref.
Les fonctions de la bibliothèque système pour les processus x86 (32 bits) ont une enveloppe spéciale par laquelle elles sont transmises à x64, exécutées et renvoyées à x86.
 
mql5:
En bref.
Les fonctions de la bibliothèque système pour les processus x86 (32 bits) ont un emballage spécial, par lequel elles sont transférées vers x64, exécutées et renvoyées vers x86.

Merci pour ces informations.

Pouvez-vous m'indiquer comment faire de même sur votre propre site ? un lien (si disponible).

 
MetaDriver:


Allez-vous rétrécir ? ;)

Non, j'utilise des tableaux unidimensionnels chaque fois que c'est possible.
 
#ifdef n'est-il pas la solution normale au problème ?
 
Yurich:
Non, j'utilise des tableaux unidimensionnels chaque fois que c'est possible.

OK. Les questions d'optimisation sont secondaires dans ce cas, l'exploit est de toute façon défendu.

--

Je peux vous proposer le problème suivant.

Le tableau a une dimensionnalité arbitraire (limitons-la à ^16 pour plus de clarté).

La dimensionnalité est définie à la création par le nombre de paramètres, comme pour les tableaux habituels.

XXArray  xx2(5,7),  xx5(12,12,16,16,8);

Devrait fonctionner pour tous les indexeurs de dimensions ( A[i][j][k][n][m]....)

Juste pour le sport et l'entraînement cérébral. :)
123456789
Nouveau commentaire