你如何看待2030年的Metatrader X？ - 页 6

新评论
 
fxsaber:

将任何数据写入全局可以在这里 看到相应的inludes。

好吧，我还没有看到这个解决方案。

这不容易弄清楚，你必须检查

 
fxsaber:

任何写入全局的数据都可以在这里 看到相应的inludes。

你是否意识到，除了虱子，还有一个巨大的其他数据世界？你要的是奇怪的--写/读一个类实例的数据。

 
Igor Makanu:

好吧，我还没有看到这个解决方案。

这不容易搞清楚，你必须去看看。

是向/从资源中写入和读取原始数据。好例子，谢谢!

但是，我尊敬的fxsaber做同样的事情的班级如何？可以，即使有防卫，人们也保证不会发疯)))

 
Alexey Volchanskiy:

那不是可乐吗，哦，老奶奶们。


没有。姜饼期货。

 
Alexey Volchanskiy:

你是否意识到，除了虱子，还有一个巨大的其他数据世界？

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

我们需要像字符串这样的全局终端变量吗？

fxsaber, 2017.04.10 18:25

void OnStart()
{
  string Name = "Name";

// Записываем/считываем строки
  _GlobalVariableSet(Name, "Hello World!");
  Print(_GlobalVariableGet<string>(Name));

// Записываем/считываем простые структуры
  MqlTick Tick;
  SymbolInfoTick(_Symbol, Tick);

  _GlobalVariableSet(Name, Tick);
  Print(_GlobalVariableGet<MqlTick>(Name).time);

// Записываем/считываем массивы
  MqlTick Ticks[2];

  Ticks[0] = Tick;
  Ticks[1] = Tick;

  _GlobalVariableSet(Name, Ticks);

  MqlTick NewTicks[];

//  if (_GlobalVariableGet(Name, NewTicks)) // https://www.mql5.com/ru/forum/1111/page1868#comment_4853867
//    Print(NewTicks[1].time);

  _GlobalVariableDel(Name);
}


我想要一个奇怪的--写/读一个类的实例的数据。

我在结构中存储数据，就像开发人员一样。这很方便，也很符合逻辑。所以在这个问题上我没有看向类，尽管没有指向结构的指针。

 
fxsaber:


我在结构中存储数据，开发人员也是如此。这很方便，也很符合逻辑。 因此，在这个问题上，我还没有研究过类，尽管我没有指向结构的指针。

我建立了用于检查的脚本，但我不知道如何读取MqlTick数组

#property strict
#include <fxsaber\TypeToBytes.mqh>        //https://www.mql5.com/ru/code/16282
#define  POSTFIX "___"

string GetName( const string Name, const int Num, const string PostFix = POSTFIX )
{
  return(Name + PostFix + (string)Num);
}

bool _GlobalVariableDel( const string Name )
{
  return(GlobalVariableDel(Name) && (GlobalVariablesDeleteAll(Name + POSTFIX) >= 0));
}

#define  GLOBAL_VARIABLE_SET(A)                                                        \
template <typename T>                                                                 \
  datetime _GlobalVariableSet( const string Name, const T A )                         \
  {                                                                                   \
    _GlobalVariableDel(Name);                                                         \
                                                                                      \
    double Array[];                                                                   \
                                                                                      \
    const datetime Res = GlobalVariableSet(Name, _ArrayCopy(Array, _R(Value).Bytes)); \
    const int Size = ArraySize(Array);                                                \
                                                                                      \
    for (int i = 0; i < Size; i++)                                                    \
      GlobalVariableSet(GetName(Name, i), Array[i]);                                  \
                                                                                      \
    return(Res);                                                                      \
  }

GLOBAL_VARIABLE_SET(Value)
GLOBAL_VARIABLE_SET(&Value)
GLOBAL_VARIABLE_SET(&Value[])

#define  GLOBAL_VARIABLE_GET(A)                                              \
  {                                                                         \
    double Array[];                                                         \
                                                                            \
    const int Amount = (int)Tmp;                                            \
    const int Size = ArrayResize(Array, Amount / sizeof(double) +           \
                                 ((Amount % sizeof(double) == 0) ? 0 : 1)); \
                                                                            \
    for (int i = 0; i < Size; i++)                                          \
      Array[i] = GlobalVariableGet(GetName(Name, i));                       \
                                                                            \
    uchar Bytes[];                                                          \
                                                                            \
    _ArrayCopy(Bytes, Array, 0, 0, Amount);                                 \
                                                                            \
    _W(A) = Bytes;                                                          \
  }

template <typename T>
const T _GlobalVariableGet( const string Name )
{
  T Res; // https://www.mql5.com/ru/forum/1111/page1869#comment_4854112

  double Tmp;

  if (GlobalVariableGet(Name, Tmp))
    GLOBAL_VARIABLE_GET(Res)

  return(Res);
}

template <typename T>
bool _GlobalVariableGet( const string Name, T &Value )
{
  double Tmp;
  const bool Res = GlobalVariableGet(Name, Tmp);

  if (Res)
    GLOBAL_VARIABLE_GET(Value)

  return(Res);
}


void OnStart()
  {
   string Name="Name";

// Записываем/считываем строки
   _GlobalVariableSet(Name,"Hello World!");
   Print(_GlobalVariableGet<string>(Name));

// Записываем/считываем простые структуры
   MqlTick Tick;
   SymbolInfoTick(_Symbol,Tick);

   _GlobalVariableSet(Name,Tick);
   Print("time --> ",_GlobalVariableGet<MqlTick>(Name).time);
   Print("bid --> ",_GlobalVariableGet<MqlTick>(Name).bid);

// Записываем/считываем массивы
   MqlTick Ticks[2];

   Ticks[0] = Tick;
   Ticks[1] = Tick;

   _GlobalVariableSet(Name,Ticks);
   
//    Print("time --> ",_GlobalVariableGet<MqlTick>(Name).time);
//    Print("bid --> ",_GlobalVariableGet<MqlTick>(Name).bid);
   
   _GlobalVariableDel(Name);
  }
//+------------------------------------------------------------------+


PS: 编译器警告说可能使用了未初始化的变量'Res'，如果可能的话应该删除。


 
Alexey Volchanskiy:

就个人而言，我怀念多任务处理。我记得（10行怀旧，青春跳过），早在2000年，当奔腾4发布时，我正在RSDN程序员论坛上闲逛。而英特尔在P4上的频率约为15GHz。是的，我不是在开玩笑，这一切都在这里。好吧，我不知道他们是否真的这么想，或者这是个骗局，但我不相信，毕竟我是一个铁人。

然后我做了一个关于多核即将到来的大主题，你会看到，我们需要做好准备。人们笑了，这就像一个童话故事，你怎么能编写平行代码？这是个幻想。

那么谁是对的呢？英特尔的15Ghz失败了，然后桌面版收到双核奔腾D，然后是突破性的双核。

而我们在MQL5上仍然生活在199*年。没有多线程，没有例外...出于悲痛，去买了一个西瓜...

从MT5的描述中可以看出，它是多线程的。由于现代CPU是用户下的可执行代码的垃圾箱，那么就有了西瓜，所有的线程都没有务实的意义。企业既不关心高效的代码，也不关心计算能力的合理使用：如果不够用--就买更多。

P.S. 也许是1.5GHz？我可能是错的，在那些年里，他们定义了5纳米的物理技术极限，并以此为基础定义了所谓的GHz。希望在几年内从200纳米到5纳米，就像这样--当然会。

 

2030年，metatrader将被禁止。

将禁止一切的人将上台。

然后，世界上将有一个支付系统。

还有全世界的一个统治者。

他将开始在每个人身上安装芯片，将每个人置于GLONASS、5G之下。

将不会有现金。付款将通过植入身体的芯片进行。

只有社会上的特权成员才会被允许在互联网上交易--那些认为这个统治者是真正的神的人...


阿门。

 
Igor Makanu:

我建立了一个脚本来测试它，但我不知道如何读取MqlTick数组。

添加这个重载

template <typename T>
bool _GlobalVariableGet( const string Name, T &Value[] )
{
  double Tmp;
  const bool Res = GlobalVariableGet(Name, Tmp);

  if (Res)
  {
    double Array[];                                                         
                                                                            
    const int Amount = (int)Tmp;                                            
    const int Size = ArrayResize(Array, Amount / sizeof(double) +           
                                 ((Amount % sizeof(double) == 0) ? 0 : 1)); 
                                                                            
    for (int i = 0; i < Size; i++)                                          
      Array[i] = GlobalVariableGet(GetName(Name, i));                       
                                                                                                                                                        
    _ArrayCopy(Value, Array, 0, 0, Amount);
  }  

  return(Res);
}
伊戈尔-马卡努。

PS: 编译器警告说可能使用了未初始化的变量'Res'，如果可能的话，可以删除。

添加这一行

  T Res;
  ZeroMemory(Res);
 
Unicornis:

从MT5的描述中可以看出，它是多线程的。由于现代处理器在其工作中用户是可执行代码的转储，仍有西瓜，在所有线程中没有务实的意义。企业既不关心高效的代码，也不关心计算能力的合理使用：如果不够用--就买更多。

P.S. 也许是1.5GHz？我可能是错的，在那些年里，他们将技术的物理极限定义为5纳米，并由此定义了所谓的GHz。 我想从200纳米到5纳米，就这样在几年内完成--我当然愿意。

我是个文盲，不看说明书。但我知道MT5只在优化器中是多线程的）。在测试器中，它只在一个线程中工作。

要实现并行化，你可以使用OpenCL，但这项技术本身只是由MT5支持。

而关于路线图中的15GHz，我确信，我有程序员的记忆，我看到的东西，我永远不会忘记。

12345678910
新评论