기능 - 구조 배열을 정렬하는 방법입니다. 상금 10$ - 페이지 3

[Vladimir Pastushak]

fxsaber :

모든 경우에 답이 있는 것은 아닙니다. 대부분 문을 닫습니다.

도움을 주신 fxsaber 에 감사드립니다! 10 $를 송금하는 곳

[TheXpert]

Maxim Kuznetsov :

mql에서 직접 실현할 수 없습니다.

[fxsaber]

Vladimir Pastushak :

도움을 주신 fxsaber 에 감사드립니다! 10 $를 송금하는 곳

별말씀을요.

[Vladimir Pastushak]

fxsaber :

별말씀을요.

정렬된 구조에 문자열 데이터가 있으면 메서드가 작동하지 않습니다...

[fxsaber]

Vladimir Pastushak :

정렬된 구조에 문자열 데이터가 있으면 메서드가 작동하지 않습니다...

이것을 활용 하십시오 .

[Maxim Kuznetsov]

TheXpert :
mql에서 직접 실현할 수 없습니다.

하지만 그건 그렇고, yes :-( (의사) 함수 포인터는 템플릿이 될 수 없습니다

그런 것이있는 것처럼 보이지만 ...

C/C++ 이후에 이 동작은 MQL에서 "불멸의 것을 생성"하려는 시도를 방해합니다. 특정 프라이빗 솔루션만

[Vladimir Pastushak]

fxsaber :

이것을 활용 하십시오 .

그리고 이것은 더 이상 작동하지 않습니다

템플릿 선언은 로컬 클래스에서 허용되지 않습니다.

[Sergey Dzyublik]

Maxim Kuznetsov :

하지만 그건 그렇고, 예 :-( (의사) 함수 포인터는 템플릿이 될 수 없습니다

그런 일이있는 것처럼 보이지만 ...

C/C++ 이후에 이 동작은 MQL에서 "불멸의 것을 생성"하려는 시도를 방해합니다. 특정 프라이빗 솔루션만

뭐가 문제 야???
원하는 경우 제안된 코드를 사용할 수도 있습니다.

 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 :

그리고 이것은 더 이상 작동하지 않습니다

템플릿 선언은 로컬 클래스에서 허용되지 않습니다.

작동하는지 확인했습니다.

[Sergey Dzyublik]

열렬한 팬은 자신의 개발 내용을 공유하지 않으므로 Pod 어레이에 대한 일부 실행 속도 최적화가 중단되었습니다.
대신 약간 확장된 기능:
- MT4(빌드 1262, ME 2380) 및 MT5(빌드 2380, ME 2380)용으로 컴파일됨
- Pod 및 NonPod 구조 모두에 대한 지원이 있습니다.
- 구조의 정적 및 동적 배열 과 함께 작동합니다.

 #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;     
   }
};