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

新评论
 
Nikolai Semko #:

意味着在战斗模式下，你应该关闭所有图形上的废话而不进行最小化。如果窗口保持可见但不活动，让图形被冻结。
而且，在我看来，当鼠标不活动时，例如 1分钟，自动关闭和删除所有图形，会更容易和更好。一旦鼠标被激活--图形就会恢复。

这一点也不好。在这里，你看了2分钟的图，而图在1分钟前就死了。那么有什么必要呢？

 
Vitaly Muzichenko #:

这一点也不好。你看了两分钟的图，图在一分钟前就死了。那么它是用来做什么的？

嗯，当然，你需要一个 "自动隐藏 "开关来实现这一模式。

 
Nikolai Semko #:

意味着在战斗模式下，所有的图形开销都必须被关闭，而不是最小化。

图表本身的画布是在没有最小化的情况下绘制的。经验丰富的方式是发现终端操作的模式，当VPS被加载到最小的时候。

 

我希望我写的是正确的主题。

1.同时在几个货币对上运行测试，多货币

问题：我怎样才能得到每一对的结果？

2我们同时对几对进行优化

问题：如何获得每一对的结果？

---

前段时间，大约3年前，他们承诺将在测试器中加入这个功能，但到目前为止，还没有任何消息。还是我没有找到？

 

例如，有一种合法的方式可以停止市场顾问或信号服务的工作。比方说，由于这样或那样的原因，无法访问它们 - VPS。

如果在交易服务器上有限制，该方法将发挥作用。你只需要用挂单来填补一切，但要小心，否则就不可能关闭未结头寸。


也许有人会写这样一个紧急市场产品...

 

MQL5。MESSAGE BOX重复了 "专家 "日志中的信息。请告知如何禁用它。***

谢谢你!

 

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

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

fxsaber, 2017.09.22 20:43

POSITION_TIME_UPDATE 只与改变仓位的批次有关。例如，任何类型账户的部分平仓或净值化附加。

SL/TP水平的变化不影响POSITION_TIME_UPDATE。

解释一下，POSITION_TIME_UPDATE只受反映在交易历史--交易中的修改的影响。SL/TP级别不适用于这种修改，所以它们不受影响。

可能会出现这样的情况：尽管地段大小有变化，但POSITION_TIME_UPDATE_MSC == POSITION_TIME_UPDATE。

 
与此主题无关的评论已被移至"新手对MQL4和MQL5的任何问题，对算法和代码的帮助和讨论"。
 
fxsaber #:
便于对数组 结构进行排序


应用


结果

你好，谢谢你的分享!

如果能成功，这将是完美的。然而，当把你的代码粘贴到.mq5脚本中并执行时，不幸的是你的代码出现了以下错误。

  • 本地类中不允许使用模板声明 ArraySortStruct.mq5 87 4
  • (在稍微 改变你的代码后)：模板声明只允许在全局、命名空间或类的范围内进行 ArraySortStruct.mq5 90 4 )

能否请你解决这个问题？对你来说，这可能很容易，而我却不知道从哪里开始 :-)

 
Bodolino #:

你好，谢谢你的分享!

如果能成功，这将是完美的。然而，当把你的代码粘贴到.mq5脚本中并执行时，不幸的是你的代码出现了以下错误。

  • 本地类中不允许使用模板声明 ArraySortStruct.mq5 87 4
  • (在稍微 改变你的代码后)：模板声明只允许在全局、命名空间或类的范围内进行 ArraySortStruct.mq5 90 4 )

能否请你解决这个问题？对你来说，这可能很容易，而我却不知道从哪里开始 :-)

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

// Сортировка массива структур и указателей на объекты 
по полю.
#define  ArraySortStruct_Define(TYPE, FIELD)                                      \
namespace TYPE##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(TYPE, ARRAY, FIELD) TYPE##FIELD::SORT::Sort(ARRAY)


申请。

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);
}
1...213214215216217218219220221222223224225226227...247
新评论