Funzione - Metodo per ordinare un array di strutture. Premio 10$ - pagina 8

Nuovo commento
 
Georgiy Merts:

Personalmente, ho scritto io stesso molto tempo fa una classe CStructWrapper, ereditata da CObject (CMyObject è in realtà la stessa cosa, con campi di debug aggiuntivi), e per l'ordinamento uso una funzione standard.

Se ho bisogno di un array di strutture, dichiaro una classe derivata basata su questo modello. In esso, dichiaro una funzione per confrontare i campi necessari della struttura. E poi - uso una classe standard di un array di oggetti con ordinamento.

Gli oggetti creati possono essere copiati direttamente dalle strutture usando l'operatore di assegnazione. Se necessario, li copio.

Sfortunatamente, non sono così esperto in OOP da poter capire il tuo codice.

 
Vladimir Pastushak:

Purtroppo, non sono ancora abbastanza forte in OOP per capire il tuo codice.

È solo una classe che contiene la nostra struttura all'interno.

E tutti i tipi di operatori di copia, permettendo di usare il segno di assegnazione (=) direttamente tra l'oggetto e la struttura.

Quando ho bisogno di un array di strutture - creo un array di tali oggetti. Ognuno ha la struttura richiesta. Inoltre, una funzione di confronto è definita in questa classe, che è necessaria per l'ordinamento e la ricerca. Tutte le funzioni standard della classe CArrayObj sono utilizzate

 
Vladimir Pastushak:

Purtroppo, non sono ancora abbastanza forte in OOP per capire il tuo codice.

Bene, implementate il metodo senza OOP. Non preoccupatevi, potete prendere il metodo "quick sorting" da SB( ci sono moltialgoritmi di ordinamento, qualcuno ha caricato un video come la visualizzazione di diversi algoritmi, ognuno è migliore in qualche situazione, ma questo è ottimale e il più usato) e cambiarlo per la vostra struttura, qui dovreste scegliere, da quale campo della struttura confronterete più o meno. circa così (supponiamo da qualche stringayour_value)

//+------------------------------------------------------------------+
//| 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:

Purtroppo, non sono ancora abbastanza forte in OOP per capire il tuo codice.

Ma almeno sei bravo a distinguere *** da ***?

 
Vladimir Pastushak:

Purtroppo ora anche i metodi suggeriti da fxsaber non funzionano più.

E sto cercando metodi per ordinare un array di strutture. Qualcuno ha qualche variante funzionante?

Penso che un tale workaround alla limitazione della lingua funzionerebbe.

#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:

Ma almeno sei bravo a distinguere *** da ***?

Proprio come le persone... credo che mi abbiate confuso con qualcun altro...

 
Vladimir Pastushak:

Anche la gente... Credo che mi abbia confuso con qualcun altro...

Questo è il punto: penso di esserlo. Ma non lo sono.

 
Dmitry Fedoseev:

Questo è il punto, "sembra". Ma non sono confuso.

Cos'è tutto questo "attrito"? Cosa c'entra con l'argomento?

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

Che senso ha tutto questo "attrito"? Cosa c'entra questo con l'argomento?

Perché? C'è un topic separato per questo?

 
Aleksey Mavrin:

Bene, implementate il metodo senza OOP. Non andare troppo lontano, prendi il metodo "quick sort" da SB

fxsaber:

Penso che un tale workaround alla limitazione della lingua possa andare bene.

Grazie, amici!

L'ho messo nel mio buco.

123456789
Nuovo commento