In MQL5 gibt es immer Raum für einen Exploit! ;) - Seite 2

Neuer Kommentar
 
sergeev:

Das ist die erste Frage.

Wie importiert man Funktionen aus 32-Bit-DLLs wie user32.dll usw. in eine 64-Bit-Anwendung? Oder gibt es für sie Kopien im System mit diesem Namen und es wird ein OOP-Space erstellt?

Nun, zunächst einmal haben x64-Systeme einen emulierten Start von x86-Programmen. Die Frage ist, wie man x64-Programme in x86 ausführen kann?
 
Urain:
Nun, zunächst einmal haben x64-Systeme einen emulierten Start von x86-Programmen. Die Frage ist, wie man x64-Programme in x86 ausführen kann?

Vielleicht ist die Frage nicht über das Terminal überhaupt, sondern über einige knifflige Kompilierung von diesen sehr DLLs?

Die DLLs werden von der Windows-API betrieben, z. B. user32, kernel32, winmm, wininet im 32/64-Bit-Terminal.

Die Lösung des Problems scheint woanders zu liegen.

 
Urain:
Die Frage ist, wie man x64-Programme in x86 ausführen kann?
Es wird definitiv nicht funktionieren. x86-Prozessoren können keine 64-Bit-Anweisungen ausführen.
sergeev:

Vielleicht ist die Frage nicht über das Terminal überhaupt, aber über einige knifflige Kompilierung dieser sehr DLLs?

Zum Beispiel funktionieren user32, kernel32, winmm, wininet in 32/64 Bit Terminals.

Die Lösung für dieses Problem scheint anderswo zu liegen.

Theoretisch können Sie also 32-Bit-DLLs dort und dort zum Laufen bringen.

Vielleicht ist es an der Zeit, die Entwickler anzurufen.

Vielleicht gibt es schlauere Wege der Kompilierung // Ich habe aufgehört, mit einer 32-Bit-DLL zu arbeiten, die auf "naive" Weise auf x64 kompiliert wurde. Jedenfalls gibt es Präzedenzfälle, die "existieren" (c).

Zum Beispiel user32, kernel32, winmm, wininet in einem 32/64-Bit-Terminal.

 
MetaDriver:

Also mach es in dieser Analogie... keine große Sache!... :-))

Ich werde es mir ansehen. ;)

//+------------------------------------------------------------------+
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);
}
//+------------------------------------------------------------------+
Der einfachste Weg, dies auf Ihren Fall anzuwenden.
 
Yurich:
Die einfachste Version für Ihren Fall.

Nun, für den einfachsten Fall, Kredit. "Ich schreibe dich auf" :)

Aus dem Gedächtnis, aber nicht sparsam, im Vergleich. 

    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() возвращает только размер чистого буфера, поэтому по честному добавил размер класса. :)

Ergebnis:

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

Die Differenz beträgt das 6-fache, wenn man berücksichtigt, dass ich einen Float-Puffer habe - das 3-fache. // Sie haben auch einen impliziten Speicherraub - Ihre Systemtabelle der Klassendeskriptoren (in diesem Beispiel) ist 1000*1000+1000, während meine 1 (!) ist.

Die Geschwindigkeit ist fast die gleiche.

Werden Sie schrumpfen? ;)

--

Ich habe gelogen, Ihre Unterklassen sind alle statisch, so dass der implizite Raub ein wenig übertrieben ist. Streichen Sie das. :)

 
MetaDriver:

Vielleicht ist es an der Zeit, die Entwickler anzurufen.
Kurz und bündig.
Die Systembibliotheksfunktionen für x86 (32-Bit)-Prozesse haben einen speziellen Wrapper, durch den sie an x64 weitergegeben, ausgeführt und wieder an x86 zurückgegeben werden.
 
mql5:
Kurz und bündig.
Systembibliotheksfunktionen für x86 (32-Bit)-Prozesse haben einen speziellen Wrapper, durch den sie zu x64 übertragen, ausgeführt und wieder zu x86 zurückgeführt werden.

Ich danke Ihnen für die Informationen.

Können Sie mir sagen, wie Sie das auch selbst tun können? Geben Sie einfach einen Link an (falls verfügbar).

 
MetaDriver:


Werden Sie schrumpfen? ;)

Nein, ich verwende eindimensionale Arrays, wann immer es möglich ist.
 
Ist #ifdef nicht die normale Lösung für das Problem?
 
Yurich:
Nein, ich verwende eindimensionale Arrays, wann immer es möglich ist.

GUT. Optimierungsfragen sind in diesem Fall zweitrangig, die Leistung wird ohnehin verteidigt.

--

Ich kann Ihnen das folgende Problem anbieten.

Array hat eine beliebige Dimensionalität (der Klarheit halber beschränken wir uns auf ^16).

Die Dimensionalität wird bei der Erstellung durch die Anzahl der Parameter festgelegt, wie bei üblichen Arrays.

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

Sollte für alle Dimensions-Indexer funktionieren ( A[i][j][k][n][m]....)

Nur für Sport und Gehirntraining. :)
123456789
Neuer Kommentar