MQL5'te OOP hakkında sorular - sayfa 70

[Dmitry Fedoseev]

Maxim Kuznetsov :

buna "döngü açma" denir ve herhangi bir OO olmadan ve şablonlar derleyici tarafından yapılır (en azından yapmalıdır).

Ara koda bakarsanız (birleştiricide), o zaman bir satırda döngü yerine sadece N işlem olacaktır.

Bir işlev özyinelemeli olarak çağrıldığında ne olduğunu söyleyebilir misiniz?

[Maxim Kuznetsov]

Dmitry Fedoseev :

Bir işlev özyinelemeli olarak çağrıldığında ne olduğunu söyleyebilir misiniz?

ve özyinelemeli bir nesnel işlev çağrısı yoktur :-)

N:=const bağlantısıyla verilen örnekte, özyineleme yalnızca bir şablondan kod oluşturulurken gerçekleşir ve bu kuyruktur. Referans olarak, const döngüsünü şablon özyinelemeye daraltmak ve onu bir moda kelime olarak adlandırmak için zor bir sapkınlık

makroların döngüleri olsaydı, şöyle bir şey yazılırdı:

#for x=0, x<N, x++

print("x=%d",x);

#endfor

ve makro işlemciden sonra bir dizi N baskıya dönüşecekti. (aslında sadece şablon sınıfları aracılığıyla oldu)

Diğer bir deyişle, odak yalnızca derleme zamanında N biliniyorsa çalışır.

[Dmitry Fedoseev]

Maxim Kuznetsov :

ve özyinelemeli bir nesnel işlev çağrısı yoktur :-)

N:=const bağlantısıyla verilen örnekte, özyineleme yalnızca bir şablondan kod oluşturulurken gerçekleşir ve bu kuyruktur. Referans olarak, const döngüsünü şablon özyinelemeye daraltmak ve onu bir moda kelime olarak adlandırmak için zor bir sapkınlık

makroların döngüleri olsaydı, şöyle bir şey yazılırdı:

#for x=0, x<N, x++

print("x=%d",x);

#endfor

ve makro işlemciden sonra bir dizi N baskıya dönüşecekti. (aslında sadece şablon sınıfları aracılığıyla oldu)

Diğer bir deyişle, odak yalnızca derleme zamanında N biliniyorsa çalışır.

İster inanın ister inanmayın, şablonların nasıl çalıştığını ve orada N'nin ne olduğunu ve sonucun ne olduğunu biliyorum. Ve özyinelemeli işlev çağrısıyla ilgili sorum, özyinelemeli işlev çağrısıyla ilgiliydi, nasıl olduğuyla ilgili değil mi?

[Maxim Kuznetsov]

Dmitry Fedoseev :

İster inanın ister inanmayın, şablonların nasıl çalıştığını ve orada N'nin ne olduğunu ve sonucun ne olduğunu biliyorum. Ve özyinelemeli işlev çağrısıyla ilgili sorum, özyinelemeliişlev çağrısıyla ilgiliydi, nasıl olduğuyla ilgili değil mi?

Bu tür sınavlar "zayıf mı?" :-) nedense yukarıdaki örneğin tartışıldığını düşündüm .. yanılmışım :-)

derleyici özyinelemeyi bir kuyruk özyinelemesine dönüştürebilirse (ya hemen açıkça böyledir ya da buna işaret edildi), o zaman fiziksel özyineleme olmayacak - bir döngü yapacak (ters atlama) ve her yineleme " önceki yığın çerçevesini çiğneyin.

[Dmitry Fedoseev]

Maxim Kuznetsov :

"Kötü" bir sınav türü mü? :-) nedense yukarıdaki örneğin tartışıldığını düşündüm .. yanılmışım :-)

derleyici özyinelemeyi bir kuyruk özyinelemesine dönüştürebilirse (ya hemen açıkça böyledir ya da buna işaret edildi), o zaman fiziksel özyineleme olmayacak - bir döngü yapacak (ters atlama) ve her yineleme " önceki yığın çerçevesini çiğneyin.

Ve zayıf mı? Sadece bir soru. Peki bir yolu yok.

[Vladimir Simakov]

fxsaber :

Uğraşmak bile istemiyorum. Basit yapılar yaptı.

Basit bir yapının ilk alanına hangi nedenle erişim, büyüklüğüne bağlıdır - açık değildir.

Tanrım. Her şey basmakalıp - çarpma için bit sayısı daha fazladır)))) Yapının boyutunun ikili gösterimindeki bit sayısının aynı olduğundan emin olun))) İşlemci için olduğu kadar aptalca kişi, 1111 * 101'den 1111 * 10'dan daha uzun çarpmak için)

[fxsaber]

Vladimir Simakov :
Tanrım. Her şey basmakalıp - çarpma için bit sayısı daha fazladır))))Yapının boyutunun ikili gösterimindeki bit sayısının aynı olduğundan emin olun))) İşlemci için olduğu kadar aptalca kişi, 1111 * 101'den 1111 * 10'dan daha uzun çarpmak için)

Kontrol etmeyeceğim, başka birçok görev var. Ama inanmak zor.

[fxsaber]

ME'de mqh ile çalışıyorum, ALT+N'ye basıyorum - dosyanın konumu Navigator penceresinde bir ağaç görünümünde gösteriliyor.

Şimdi onu açık bir mq5 dosyasına dahil etmek istiyorum. Fare ile ağaçtan mqh'yi mq5'e sürüklerim, ancak ilgili içerme satırı oluşturulmaz.

[Vladimir Simakov]

fxsaber :

Kontrol etmeyeceğim, başka birçok görev var. Ama inanmak zor.

 template < typename T>
size_t Func(T* arr,size_t arrSize)
{
000000013 FFC1DA0  mov         qword ptr [rsp+ 10 h],rdx  
000000013 FFC1DA5  mov         qword ptr [rsp+ 8 ],rcx  
000000013 FFC1DAA  push        rbp  
000000013 FFC1DAB  push        rdi  
000000013 FFC1DAC  sub         rsp, 148 h  
000000013 FFC1DB3  lea         rbp,[rsp+ 20 h]  
000000013 FFC1DB8  mov         rdi,rsp  
000000013 FFC1DBB  mov         ecx, 52 h  
000000013 FFC1DC0  mov         eax, 0 CCCCCCCCh  
000000013 FFC1DC5  rep stos    dword ptr [rdi]  
000000013 FFC1DC7  mov         rcx,qword ptr [rsp+ 168 h]  
000000013 FFC1DCF  lea         rcx,[__116109BC_Test@cpp ( 013 FFD5029h)]  
000000013 FFC1DD6  call        __CheckForDebuggerJustMyCode ( 013 FFC10B9h)  
     // Write
     for (size_t i = 0 ; i <arrSize; ++i)
000000013 FFC1DDB  mov         qword ptr [rbp+ 8 ], 0   
000000013 FFC1DE3  jmp         Func<STRUCT1>+ 50 h ( 013 FFC1DF0h)  
000000013 FFC1DE5  mov         rax,qword ptr [rbp+ 8 ]  
000000013 FFC1DE9  inc         rax  
000000013 FFC1DEC  mov         qword ptr [rbp+ 8 ],rax  
000000013 FFC1DF0  mov         rax,qword ptr [arrSize]  
000000013 FFC1DF7  cmp         qword ptr [rbp+ 8 ],rax  
000000013 FFC1DFB  jae         Func<STRUCT1>+ 71 h ( 013 FFC1E11h)  
        arr[i].i = i;
000000013 FFC1DFD  imul        rax,qword ptr [rbp+ 8 ], 18 h  
000000013 FFC1E02  mov         rcx,qword ptr [arr]  
000000013 FFC1E09  mov         edx,dword ptr [rbp+ 8 ]  
000000013 FFC1E0C  mov         dword ptr [rcx+rax],edx  
000000013 FFC1E0F  jmp         Func<STRUCT1>+ 45 h ( 013 FFC1DE5h)  

    size_t Sum = 0 ;
000000013 FFC1E11  mov         qword ptr [Sum], 0   

     // Read
     for (size_t i = 0 ; i < arrSize; ++i)
000000013 FFC1E19  mov         qword ptr [rbp+ 48 h], 0   
000000013 FFC1E21  jmp         Func<STRUCT1>+ 8 Eh ( 013 FFC1E2Eh)  
000000013 FFC1E23  mov         rax,qword ptr [rbp+ 48 h]  
000000013 FFC1E27  inc         rax  
000000013 FFC1E2A  mov         qword ptr [rbp+ 48 h],rax  
000000013 FFC1E2E  mov         rax,qword ptr [arrSize]  
000000013 FFC1E35  cmp         qword ptr [rbp+ 48 h],rax  
000000013 FFC1E39  jae         Func<STRUCT1>+ 0 BBh ( 013 FFC1E5Bh)  
        Sum += arr[i].i;
000000013 FFC1E3B  imul        rax,qword ptr [rbp+ 48 h], 18 h  
000000013 FFC1E40  mov         rcx,qword ptr [arr]  
000000013 FFC1E47  movsxd      rax,dword ptr [rcx+rax]  
000000013 FFC1E4B  mov         rcx,qword ptr [Sum]  
000000013 FFC1E4F  add         rcx,rax  
000000013 FFC1E52  mov         rax,rcx  
000000013 FFC1E55  mov         qword ptr [Sum],rax  
000000013 FFC1E59  jmp         Func<STRUCT1>+ 83 h ( 013 FFC1E23h)  

     return Sum + arrSize;
000000013 FFC1E5B  mov         rax,qword ptr [arrSize]  
000000013 FFC1E62  mov         rcx,qword ptr [Sum]  
000000013 FFC1E66  add         rcx,rax  
000000013 FFC1E69  mov         rax,rcx  
}
000000013 FFC1E6C  lea         rsp,[rbp+ 128 h]  

Bu küçük bir yapı için

 template < typename T>
size_t Func(T* arr,size_t arrSize)
{
000000013 FFC1EB0  mov         qword ptr [rsp+ 10 h],rdx  
000000013 FFC1EB5  mov         qword ptr [rsp+ 8 ],rcx  
000000013 FFC1EBA  push        rbp  
000000013 FFC1EBB  push        rdi  
000000013 FFC1EBC  sub         rsp, 148 h  
000000013 FFC1EC3  lea         rbp,[rsp+ 20 h]  
000000013 FFC1EC8  mov         rdi,rsp  
000000013 FFC1ECB  mov         ecx, 52 h  
000000013 FFC1ED0  mov         eax, 0 CCCCCCCCh  
000000013 FFC1ED5  rep stos    dword ptr [rdi]  
000000013 FFC1ED7  mov         rcx,qword ptr [rsp+ 168 h]  
000000013 FFC1EDF  lea         rcx,[__116109BC_Test@cpp ( 013 FFD5029h)]  
000000013 FFC1EE6  call        __CheckForDebuggerJustMyCode ( 013 FFC10B9h)  
     // Write
     for (size_t i = 0 ; i <arrSize; ++i)
000000013 FFC1EEB  mov         qword ptr [rbp+ 8 ], 0   
000000013 FFC1EF3  jmp         Func<STRUCT3>+ 50 h ( 013 FFC1F00h)  
000000013 FFC1EF5  mov         rax,qword ptr [rbp+ 8 ]  
000000013 FFC1EF9  inc         rax  
000000013 FFC1EFC  mov         qword ptr [rbp+ 8 ],rax  
000000013 FFC1F00  mov         rax,qword ptr [arrSize]  
000000013 FFC1F07  cmp         qword ptr [rbp+ 8 ],rax  
000000013 FFC1F0B  jae         Func<STRUCT3>+ 71 h ( 013 FFC1F21h)  
        arr[i].i = i;
000000013 FFC1F0D  imul        rax,qword ptr [rbp+ 8 ], 58 h  
000000013 FFC1F12  mov         rcx,qword ptr [arr]  
000000013 FFC1F19  mov         edx,dword ptr [rbp+ 8 ]  
000000013 FFC1F1C  mov         dword ptr [rcx+rax],edx  
000000013 FFC1F1F  jmp         Func<STRUCT3>+ 45 h ( 013 FFC1EF5h)  

    size_t Sum = 0 ;
000000013 FFC1F21  mov         qword ptr [Sum], 0   

     // Read
     for (size_t i = 0 ; i < arrSize; ++i)
000000013 FFC1F29  mov         qword ptr [rbp+ 48 h], 0   
000000013 FFC1F31  jmp         Func<STRUCT3>+ 8 Eh ( 013 FFC1F3Eh)  
000000013 FFC1F33  mov         rax,qword ptr [rbp+ 48 h]  
000000013 FFC1F37  inc         rax  
000000013 FFC1F3A  mov         qword ptr [rbp+ 48 h],rax  
000000013 FFC1F3E  mov         rax,qword ptr [arrSize]  
000000013 FFC1F45  cmp         qword ptr [rbp+ 48 h],rax  
000000013 FFC1F49  jae         Func<STRUCT3>+ 0 BBh ( 013 FFC1F6Bh)  
        Sum += arr[i].i;
000000013 FFC1F4B  imul        rax,qword ptr [rbp+ 48 h], 58 h  
000000013 FFC1F50  mov         rcx,qword ptr [arr]  
000000013 FFC1F57  movsxd      rax,dword ptr [rcx+rax]  
000000013 FFC1F5B  mov         rcx,qword ptr [Sum]  
000000013 FFC1F5F  add         rcx,rax  
000000013 FFC1F62  mov         rax,rcx  
000000013 FFC1F65  mov         qword ptr [Sum],rax  
000000013 FFC1F69  jmp         Func<STRUCT3>+ 83 h ( 013 FFC1F33h)  

     return Sum + arrSize;
000000013 FFC1F6B  mov         rax,qword ptr [arrSize]  
000000013 FFC1F72  mov         rcx,qword ptr [Sum]  
000000013 FFC1F76  add         rcx,rax  
000000013 FFC1F79  mov         rax,rcx  
}
000000013 FFC1F7C  lea         rsp,[rbp+ 128 h]  

Bu büyük olan için.

VS2019, Debug x64, sürümde bunları sıraladı, ancak hız aynı.

Tek fark, iki yerde üçüncü işlenen olan imul talimatlarındadır. Talimat sadece dizideki ofsetin hesaplanmasıdır ve üçüncü işlenen yapının bayt cinsinden boyutudur.

Yani, mistisizm yok - fizik yasaları iş başında.

[Igor Makanu]

Vladimir Simakov :

Yani, mistisizm yok - fizik yasaları iş başında.

böyle sınıflar yazarsanız:

 //+------------------------------------------------------------------+
struct STRUCT
{
   int i;
   double d;
   uchar uc[ 16 ];
};
//+------------------------------------------------------------------+
class A
{
private :
   int i;
   double d;
   uchar uc[ 16 ];
public :
   A( const STRUCT &ini) { i = ini.i; d = ini.d; ArrayCopy (uc,ini.uc); }
};
//+------------------------------------------------------------------+
class B
{
private :
   STRUCT data;
public :
   B( const STRUCT &ini) { data = ini; }
};
//+------------------------------------------------------------------+

Araştırmanıza bakılırsa, hesaplamalarda yapı alanlarını sıklıkla kullanırsanız B sınıfı daha yavaş mı olacak?