İşlev - Bir dizi yapıyı sıralama yöntemi. Ödül 10$ - sayfa 3

[Vladimir Pastushak]

fxsaber :

Cevap her durum için değildi. Çoğu kapalı.

Yardımın için teşekkürler fxsaber ! 10 $ nereye transfer edilir

[TheXpert]

Maxim Kuznetsov :

mql'de doğrudan gerçekleştirilemez.

[fxsaber]

Vladimir Pastushak :

Yardımın için teşekkürler fxsaber ! 10 $ nereye transfer edilir

Benim için zevkti.

[Vladimir Pastushak]

fxsaber :

Benim için zevkti.

Sıralanan yapıda dize verisi varsa, yönteminiz çalışmaz...

[fxsaber]

Vladimir Pastushak :

Sıralanan yapıda dize verisi varsa, yönteminiz çalışmaz...

Bundan yararlanın.

[Maxim Kuznetsov]

TheXpert :
mql'de doğrudan gerçekleştirilemez.

ama bu arada, evet :-( (sözde) işlev işaretçisi şablon olamaz

öyle bir şey varmış gibi görünse de...

C/C++'dan sonra bu davranış, MQL'de "bozulmaz şeyler yaratma" girişimlerini caydırır. Yalnızca belirli özel çözümler

[Vladimir Pastushak]

fxsaber :

Bundan yararlanın.

Ve bu artık çalışmıyor

yerel sınıfta şablon bildirimlerine izin verilmez

[Sergey Dzyublik]

Maxim Kuznetsov :

ama bu arada, evet :-( (sözde) işlev işaretçisi şablon olamaz

öyle bir şey varmış gibi görünse de...

C/C++'dan sonra bu davranış, MQL'de "bozulmaz şeyler yaratma" girişimlerini caydırır. Yalnızca belirli özel çözümler

Sorun ne???
Dilerseniz önerilen kodu da kullanabilirsiniz:

 template < typename T, typename Func>
int
ArrayIndexate( const T &arr[], int &index[], Func compare)
{
   /// инициализуем индексный массив
   int size= ArraySize (arr);
   if (size==- 1 || ArrayResize (index,size)==- 1 ) {
       return - 1 ;
   }
   for ( int i= 0 ;i<size;i++)
      index[i]=i;
   /// "пузырёк" - замените более быстрым методом
   for ( int i= 0 ;i<size;i++) {
       for ( int j=i+ 1 ;j<size;j++) {
         if ( compare(arr[index[i]],arr[index[j]] ) > 0 ) {
             int swap=index[i];
            index[i]=index[j];
            index[j]=swap;
         }
      }
   }
   // в массиве index[] теперь лежат индексы элементов arr[]
   return size;   
}

void OnStart (){ 
   NonPod arr_nonpod[ 9 ];
   ArrayInit(arr_nonpod);    
   PRINT(ArrayPrintValue(arr_nonpod));                       // 9 8 7 6 5 4 3 2 1 
   
   int index[];
   LAMBDA_CREATE_P2( int , compare, const NonPod &p1, const NonPod &p2, {
       return p1.value >= p2.value;
   });
   ArrayIndexate(arr_nonpod, index, LAMBDA_FUNC(compare));
   
   string result = "" ;
   for ( int i = 0 ; i < ArraySize (index); ++i){
      result += string (arr_nonpod[index[i]].value) + " " ;   
   }
   PRINT(result);                                           //1 2 3 4 5 6 7 8 9 
}

[fxsaber]

Vladimir Pastushak :

Ve bu artık çalışmıyor

yerel sınıfta şablon bildirimlerine izin verilmez

Çalıştığını kontrol etti.

[Sergey Dzyublik]

Çok büyük bir hayran kendi geliştirmelerini paylaşmaz, bu nedenle Pod dizileri için bazı yürütme hızı optimizasyonları kesildi.
Bunun yerine, biraz genişletilmiş işlevsellik:
- MT4 (yapı 1262, ME 2380) ve MT5 (yapı 2380, ME 2380) için derlenmiştir;
- hem Pod hem de NonPod yapıları için destek vardır;
- statik ve dinamik yapı dizileriyle çalışır;

 #property strict
#define PRINT(x) ; Print ( #x, ":" , string (x))
#define CONSTRAINT(ex) if ( false ){ string test = typename (ex);}

//+------------------------------------------------------------------+
//| Test Inviroment                                                  |
//+------------------------------------------------------------------+
struct Pod{
   int value;
};

struct NonPod : public Pod{
   uchar data[];
};

template < typename T>
void ArrayInit(T &arr[]){
   int size = ArraySize (arr);
   for ( int i = 0 ; i < size; ++i){
      arr[i].value = size - i;
   }
}

template < typename T>
string ArrayPrintValue(T &arr[]){
   string result = "" ;
   for ( int i = 0 ; i < ArraySize (arr); ++i){
      result += string (arr[i].value) + " " ;
   }
   return result;
}

//+------------------------------------------------------------------+
//| Fixed code                                                       |
//+------------------------------------------------------------------+
template < typename T>                                       
void ArrayReindex( T &Array[], const double &TmpSort[][ 2 ] )
{                         
   T TmpArray[];
   for ( int x = :: ArrayResize (TmpArray, :: ArrayRange (TmpSort, 0 )) - 1 ; x >= 0 ; x--){
      TmpArray[x] = Array[( int )(TmpSort[x][ 1 ] + 0.1 )];
   }

#ifdef __MQL5__     
   if (!:: ArraySwap (Array, TmpArray)){
      ArrayFunctions:: ArrayCopy (Array, TmpArray);
   }
#endif 
#ifdef __MQL4__
   ArrayFunctions:: ArrayCopy (Array, TmpArray);
#endif              
   return ;     
}             

// Сортировка массива структур и указателей на объекты по (под-) полю/методу. 
#define ArraySortStruct(ARRAY, FIELD)                                         \
{                                                                             \
   double TmpSort[][ 2 ];                                                       \
   int size = :: ArraySize (ARRAY);                                             \
   :: ArrayResize (TmpSort, :: ArraySize (ARRAY));                                \
   for ( int x = size - 1 ; x >= 0 ; x--)                                        \
   {                                                                          \
    TmpSort[x][ 0 ] = ( double )ARRAY[x].FIELD;                                   \
    TmpSort[x][ 1 ] = x;                                                        \
   }                                                                          \
                                                                              \
   :: ArraySort (TmpSort);                                                      \
   ::ArrayReindex(ARRAY, TmpSort);                                            \
} 

//+------------------------------------------------------------------+
//| Test                                                                 |
//+------------------------------------------------------------------+
void OnStart (){
   Pod arr_pod[ 9 ];
   NonPod arr_nonpod[];
   ArrayResize (arr_nonpod, 9 );

   ArrayInit(arr_pod); 
   ArrayInit(arr_nonpod);
   
   PRINT(ArrayPrintValue(arr_pod));       // 9 8 7 6 5 4 3 2 1 
   PRINT(ArrayPrintValue(arr_nonpod));   // 9 8 7 6 5 4 3 2 1 
   
   ArraySortStruct(arr_pod, value);
   ArraySortStruct(arr_nonpod, value);
   
   
   PRINT(ArrayPrintValue(arr_pod));       // 1 2 3 4 5 6 7 8 9 
   PRINT(ArrayPrintValue(arr_nonpod));   // 1 2 3 4 5 6 7 8 9 
}

//+------------------------------------------------------------------+
//| Optimization Standat Array Functions                             |
//+------------------------------------------------------------------+
class ArrayFunctions{   
public :
//+------------------------------------------------------------------+
//| Copies an array into another one                                 |
//+------------------------------------------------------------------+
   template < typename T_dst, typename T_src>
   static int ArrayCopy (T_dst &dst_array[], const T_src &src_array[], int dst_start = 0 , int src_start = 0 , int count = WHOLE_ARRAY ){
      CONSTRAINT(dst_array[ 0 ] = src_array[ 0 ]);
       if (dst_start < 0 || src_start < 0 ){
         return - 1 ;
      }
       if ( ArraySize (src_array) - src_start <= 0 ){
         return - 1 ;
      }
       int max_count = MathMin ( ArraySize (dst_array) - dst_start, ArraySize (src_array) - src_start);
      count = count > 0 ? count : max_count;
      count = count < max_count ? count : max_count;      
      
       int result = ArrayCopy_AnyType(dst_array, src_array, dst_start, src_start, count);
       return result;
   }
//+------------------------------------------------------------------+
private :  
   template < typename T_dst, typename T_src>
   static int ArrayCopy_AnyType(T_dst &dst_array[], const T_src &src_array[], int dst_start, int src_start, int count){
       int dst_size = dst_start + count;
       if (dst_size > ArraySize (dst_array)){
         ArrayResize (dst_array, dst_size);
      }
       if (dst_size >= src_start && dst_start <  src_start){
         for ( int i = 0 ; i < count; ++i){
            dst_array[dst_start + i] = src_array[src_start + i];
         }
      }
       else {
         for ( int i = count - 1 ; i >= 0 ; --i){
            dst_array[dst_start + i] = src_array[src_start + i];
         }
      }
       return count;     
   }
};