関数 - 構造体の配列をソートするためのメソッド。賞金10ドル - ページ 8

新しいコメント
 
Georgiy Merts:

個人的には、昔、CObjectを継承したCStructWrapperクラス（CMyObjectも実は同じで、デバッグ用のフィールドが追加されています）を自作して、ソート用に標準の関数を使用しています。

構造体の配列が必要な場合は、このテンプレートを元に派生クラスを宣言します。その中で、構造体の必要なフィールドを比較するための関数を宣言しています。 そして、ソートを持つオブジェクトの配列の標準的なクラスを使っています。

作成したオブジェクトは、代入演算子を使って構造体から直接コピーすることができます。必要であればコピーもします。

残念ながら、私はOOPの経験があまりないので、あなたのコードを理解することはできませんでした。

 
Vladimir Pastushak:

残念ながら、私はまだOOPに強くないので、あなたのコードを理解することはできません。

これは、私たちの構造を内部に含む単なるクラスです。

また、あらゆる種類のコピー演算子があり、オブジェクトと構造体の間で直接代入記号（=）を使用することができます。

構造体の配列が必要な場合は、そのようなオブジェクトの配列を作成します。それぞれに必要な構造を備えています。また、ソートや検索に必要な比較関数も本クラスで定義されている。すべて、CArrayObjクラスの 標準的な関数が使用されます。

 
Vladimir Pastushak:

残念ながら、私はまだOOPに強くないので、あなたのコードを理解することはできません。

では、OOPなしでメソッドを実装してください。心配しないでください。SBの「クイックソート」メソッド（ソートアルゴリズムは たくさんあり、誰かが様々なアルゴリズムの視覚化のようなビデオをアップロードしています、いくつかの状況では誰もが優れていますが、これは最適で最も広く使われています）をあなたの構造用に変更することができます。

//+------------------------------------------------------------------+
//| Method QuickSort                                                 |
//+------------------------------------------------------------------+
void CArrayString::QuickSort(int beg,int end,const int mode)
  {
   int    i,j;
   string p_string;
   string  YOUR_STRUCT t_string;
//--- check
   if(beg<0 || end<0)
      return;
//--- sort
   i=beg;
   j=end;
   while(i<end)
     {
      //--- ">>1" is quick division by 2
      p_string=m_data[(beg+end)>>1].your_value;
      while(i<j)
        {
         while(m_data[i].your_value<p_string)
           {
            //--- control the output of the array bounds
            if(i==m_data_total-1)
               break;
            i++;
           }
         while(m_data[j].your_value>p_string)
           {
            //--- control the output of the array bounds
            if(j==0)
               break;
            j--;
           }
         if(i<=j)
           {
            t_string=m_data[i];
            m_data[i++]=m_data[j];
            m_data[j]=t_string;
            //--- control the output of the array bounds
            if(j==0)
               break;
            j--;
           }
        }
      if(beg<j)
         QuickSort(beg,j);
      beg=i;
      j=end;
     }
  }
 
Vladimir Pastushak:

残念ながら、私はまだOOPに強くないので、あなたのコードを理解することはできません。

でも、少なくとも***と***の区別はついているんでしょうね？

 
Vladimir Pastushak:

残念ながら今はfxsaberが提案した方法ですらうまくいかなくなっています。

そして、構造体の配列をソート する方法を探しています。どなたか、動作するバリアントをお持ちではないでしょうか？

そのような言語制限の回避策は有効だと思います。

#property strict

// Сортировка массива структур и указателей на объекты по (под-) полю/методу.
#define  ArraySortStruct(T, ARRAY, FIELD)                                         \
{                                                                                \
  class SORT                                                                     \
  {                                                                              \
  private:                                                                       \
    static void Swap( T &Array[], const int i, const int j )                     \
    {                                                                            \
      const T Temp = Array[i];                                                   \
                                                                                 \
      Array[i] = Array[j];                                                       \
      Array[j] = Temp;                                                           \
                                                                                 \
      return;                                                                    \
    }                                                                            \
                                                                                 \
    static int Partition( T &Array[], const int Start, const int End )           \
    {                                                                            \
      int Marker = Start;                                                        \
                                                                                 \          
      for (int i = Start; i <= End; i++)                                         \
        if (Array[i].##FIELD <= Array[End].##FIELD)                              \
        {                                                                        \
          SORT::Swap(Array, i, Marker);                                          \
                                                                                 \
          Marker++;                                                              \
        }                                                                        \
                                                                                 \
       return(Marker - 1);                                                       \
    }                                                                            \
                                                                                 \
    static void QuickSort( T &Array[], const int Start, const int End )          \
    {                                                                            \
      if (Start < End)                                                           \
      {                                                                          \
        const int Pivot = Partition(Array, Start, End);                          \
                                                                                 \
        SORT::QuickSort(Array, Start, Pivot - 1);                                \
        SORT::QuickSort(Array, Pivot + 1, End);                                  \
      }                                                                          \
                                                                                 \
      return;                                                                    \
    }                                                                            \
                                                                                 \
  public:                                                                        \
    static void Sort( T &Array[], int Count = WHOLE_ARRAY, const int Start = 0 ) \
    {                                                                            \
      if (Count == WHOLE_ARRAY)                                                  \
        Count = ::ArraySize(Array);                                              \
                                                                                 \
      SORT::QuickSort(Array, Start, Start + Count - 1);                          \
                                                                                 \
      return;                                                                    \
    }                                                                            \
  };                                                                             \
                                                                                 \
  SORT::Sort(ARRAY);                                                             \
}

void OnStart()
{
  MqlRates Rates[];
  
  CopyRates(_Symbol, PERIOD_CURRENT, 0, 5, Rates); // Взяли бары
  
  Print("\nБары без сортировки - как получили.");
  ArrayPrint(Rates);
  
  Print("\nСортируем по open-цене.");
  ArraySortStruct(MqlRates, Rates, open);
  ArrayPrint(Rates);

  Print("\nСортируем по high-цене.");
  ArraySortStruct(MqlRates, Rates, high);
  ArrayPrint(Rates);

  Print("\nСортируем по времени.");
  ArraySortStruct(MqlRates, Rates, time);
  ArrayPrint(Rates);
}
 
Dmitry Fedoseev:

でも、少なくとも***と***の区別はついているんでしょうね？

人と同じように... 私を誰かと勘違いしているようだ...

 
Vladimir Pastushak:

人間もそうだ...誰かと勘違いしているようだが...。

それが、自分ではそう思っているのです。でも、私は違うんです。

削除済み  
Dmitry Fedoseev:

それが、「らしい」のです。でも、迷っているわけではないんです。

この "摩擦 "は何なのでしょうか？それとこのテーマとはどういう関係があるのですか？

 
Сергей Таболин:

この "摩擦 "は何なのか？この件と何か関係があるのでしょうか？

なぜ？これについては、別のトピックがあるのでしょうか？

 
Aleksey Mavrin:

では、OOPなしでメソッドを実装してください。行き過ぎないように、SBから「クイックソート」方式を取り入れる

fxsaber:

そんな言語制限の回避策でもいいと思うんです。

ありがとう、友よ!

穴に入れた。

123456789
新しいコメント