mql5语言的特点、微妙之处以及技巧

Bodolino 2022.02.11 17:03 #2201

fxsaber #:

不知道如何保持功能（子字段和方法）和实用性。也许这个选项会适合你的需要。

申请。

这真是太快了，现在工作得很好，谢谢你!

敬爱的俄罗斯❤️!;-)

fxsaber 2022.02.14 10:27 #2202

曾几何时，在MQL5中写这样一个宏是很容易的。

class MqlRatestime
{
public:
  static void f( MqlRates &Value ) { Print(Value.time); }
};

class MqlTicktime
{
public:
  static void f( MqlTick &Value ) { Print(Value.time); }
};

void OnStart()
{  
  MqlRates Rates;
  MqlTick Tick;
  
  MACROS(Rates, time); // MqlRatestime::f(Rates);
  MACROS(Tick, time);  // MqlTicktime::f(Tick);
}

在当前版本的MQL5中，这是否可能？我没有克服这一障碍的聪明才智。

template declarations are allowed on global, namespace or class scope only

mktr8591 2022.02.19 15:37 #2203

fxsaber #:
曾几何时，在MQL5中写这样一个宏是很容易的。

在当前版本的MQL5中，这是否可能？我还没有足智多谋的能力来克服这个障碍。

我不明白这个任务--你需要MqlRatest类（它的模板）在一个宏替换里面声明吗？

Sergey Gridnev 2022.02.19 15:48 #2204

mktr8591 #:
我不明白这个任务--你需要MqlRatest类（它的模板）在宏置换中被声明？

在我看来，有必要对不同类型的参数进行不同的宏替换。

只是我不明白为什么要用宏替换而不是函数重载来做。

fxsaber 2022.02.19 15:55 #2205

mktr8591 #:
我不明白这个任务--你需要MqlRatest类（它的模板）在宏置换里面声明？

不，这些类已经被声明了。评论中指定了你想得到的结果。该宏的输入是一个对象，而输出是一个包含该对象类型名称的类。

fxsaber 2022.02.19 15:58 #2206

Sergey Gridnev #:
在我看来，有必要对不同类型的参数进行不同的宏替换。

只是我不明白为什么要使用宏替换而不是函数重载来完成。

这项任务是在这个基础上诞生的。

关于交易、自动交易系统和策略测试的论坛

mql5的特殊性，技巧和窍门

fxsaber, 2022.02.11 15:44

ArraySortStruct_Define(MqlRates, open)
ArraySortStruct_Define(MqlRates, high)
ArraySortStruct_Define(MqlRates, time)

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

我给输入参数涂上了颜色，我必须在其中指定类型。在这个宏中，我得到三个输入参数。而我想要两个--没有类型。

mktr8591 2022.02.19 17:55 #2207

fxsaber #:

不，这些类已经被声明了。评论中指定了你想得到的结果。该宏的输入是一个对象，而输出是一个包含该对象类型名称的类。

我不知道如何解决这个问题。

而对有两个参数的ArraySortStruct--这就是它的工作方式。

#define  ArraySortStruct(ARRAY, FIELD) SortOnField_##FIELD::SORT::Sort(ARRAY)

 ArraySortStruct_Define(SortOnField_, open)
ArraySortStruct_Define(SortOnField_, high)
ArraySortStruct_Define(SortOnField_, time)


void OnStart()
  {

   MqlRates Rates[];

   CopyRates(_Symbol, PERIOD_CURRENT, 0, 5, Rates); // Взяли бары

   Print("\nБары без сортировки - как получили.");
   ArrayPrint(Rates);

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

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

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

fxsaber 2022.02.20 14:00 #2208

mktr8591 #:

而对ArraySortStruct有两个参数--这就是它的工作方式。

你是对的，谢谢你!我在一个平坦的地方做得过头了。我把你的变体留给你整理。

// Сортировка массива структур и указателей на объекты по полю.
#define  ArraySortStruct_Define(FIELD)                                            \
namespace SortOnField_##FIELD                                                    \
{                                                                                \
  class SORT                                                                     \
  {                                                                              \
  private:                                                                       \
    template <typename T>                                                        \
    static void Swap( T &Array[], const int i, const int j )                     \
    {                                                                            \
      const T Temp = Array[i];                                                   \
                                                                                 \
      Array[i] = Array[j];                                                       \
      Array[j] = Temp;                                                           \
                                                                                 \
      return;                                                                    \
    }                                                                            \
                                                                                 \
    template <typename T>                                                        \
    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);                                                       \
    }                                                                            \
                                                                                 \
    template <typename T>                                                        \
    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:                                                                        \
    template <typename T>                                                        \
    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;                                                                    \
    }                                                                            \
  };                                                                             \
}

#define  ArraySortStruct(ARRAY, FIELD) SortOnField_##FIELD::SORT::Sort(ARRAY)

申请。

ArraySortStruct_Define(open)
ArraySortStruct_Define(high)
ArraySortStruct_Define(time)

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

ZZY 很遗憾，按子领域或方法，这是不可能的。

Roman 2022.02.21 06:40 #2209

这对任何人来说可能都不是新闻，但对我来说是意想不到的。
如果一个DLL在不同的MT5程序中同时使用，
，请记住，它只被第一个使用它的程序运行加载一次。
也就是说，无论你导入多少次，DLL环境都在一个共同的进程中。
有什么好处呢？DLL中使用的全局指针都在同一个共享进程空间中。
而这是非常方便的。

Maxim Kuznetsov 2022.02.21 06:44 #2210

Roman #:
也许这对任何人来说都不是新闻，但对我来说是意想不到的。如果DLL在不同的程序MT5, 中同时使用，请记住，它只被第一个使用它的程序加载一次。也就是说，无论你

导入多少次，DLL的状态都在一个共同的进程中。有什么好处呢？DLL中使用的全局指针都在同一个共享进程空间中。而这是非常方便的。

这不是什么新鲜事，从出生开始就是这样的。

只有当数据大于__atomic__时，才应该用关键部分来包裹/保护访问（或者用mutex到终端std::线程）。

mql5语言的特点、微妙之处以及技巧 - 页 221