MQL5中的OOP问题 - 页 88

新评论
 
Igor Makanu:
 相同的值，由于某种原因，测试的速度会 "浮动"，但在方法中通过引用传递参数 仍然更有效率。

然后是这个选项。

class E
{
   double f1( double a, double b )  { return(a + 1.0/(1.0+(double)rand())); }
   double f2( double a, double b )  { return(b + 1.0/(1.0+(double)rand())); }
   double f3( double a, double b )  { return(a/b + 1.0/(1.0+(double)rand())); }
   
public:
   double calc( const MqlTick& tick )
   {
      return f1( tick.ask, tick.bid ) + f2( tick.ask, tick.bid ) + f3( tick.ask, tick.bid );
   }
};
 
Koldun Zloy:

然后还有这个选项。

2020.07.26 10:10:52.254 class_global (EURUSD,H1) class A : : loops = 10000000000 ms=46141

2020.07.26 10:11:30.261 class_global (EURUSD,H1) class B : : loops = 10000000000 ms=38000

2020.07.26 10:12:08.258 class_global (EURUSD,H1) class C :: 循环 = 10000000000 ms=38000

2020.07.26 10:12:46.254 class_global (EURUSD,H1) class D : : 循环 = 10000000000 ms=38000

2020.07.26 10:13:24.279 class_global (EURUSD,H1) class E : : loops = 10000000000 ms=38031

2020.07.26 10:14:10.484 class_global (EURUSD,H1) class A : : loops = 10000000000 ms=46203

2020.07.26 10:14:48.570 class_global (EURUSD,H1) class B : : loops = 10000000000 ms=38078

2020.07.26 10:15:26.737 class_global (EURUSD,H1) class C :: 循环 = 10000000000 ms=38172

2020.07.26 10:16:04.734 class_global (EURUSD,H1) class D : : 循环 = 10000000000 ms=38000

2020.07.26 10:16:42.739 class_global (EURUSD,H1) class E : : loops = 10000000000 ms=38000

2020.07.26 10:17:28.886 class_global (EURUSD,H1) class A : : loops = 10000000000 ms=46141

2020.07.26 10:18:06.894 class_global (EURUSD,H1) class B : : loops = 10000000000 ms=38015

2020.07.26 10:18:44.888 class_global (EURUSD,H1) class C :: 循环 = 10000000000 ms=38000

2020.07.26 10:19:22.948 class_global (EURUSD,H1) class D : : 循环 = 10000000000 ms=38047

2020.07.26 10:20:00.983 class_global (EURUSD,H1) class E : : loops = 10000000000 ms=38047

奇怪，但没有区别

UPD: 如果我没记错的话，几年前我在MT4中找过一个错误--我向一个函数传递参数，但不是通过引用，然后我在函数体中 改变了（犯了一个错误）一个函数参数。我可以改变一个通过引用传递的参数，也许在E版本中，编译器也是通过引用传递所有参数。

 
Igor Makanu:
 很奇怪，但没有什么区别。

这没有什么奇怪的。双倍数是8字节，引用也是8字节。但引用仍然要获得数字的8个字节。

 
Koldun Zloy:

这没有什么奇怪的。双倍数是8字节，引用也是8字节。但链接仍然要获得8个字节的数字。

这很有道理，数字加起来是8个在那里，8个在后面 ))

但处理器中的总线不是8位的，每个时钟周期应该读8字节=64位？

 
Igor Makanu:

这是有道理的，而且数字加起来是8个在那里，8个在后面）)

但是，处理器中的总线不是8位，难道它应该在每个时钟周期读取8字节=64位？

那里没有那么简单。速度既取决于该对象在什么内存中，也取决于其他原因。

在一个真实的程序中，结果可能与简单的测试有很大的不同。

通常，类和结构是通过引用传递的。

简单类型只有在它返回某些值时才会通过引用传递。

 

我惊讶地发现，即使这个结构作为一个函数的结果被返回，也可以访问结构域。

这段代码工作正常（我们在函数中填充结构，然后将函数的结果复制到一个字节数组中）。

struct UcharArray
{
   uchar             byte[];
};
//+------------------------------------------------------------------+
UcharArray f()
{
   UcharArray result;
   for(uchar i = 0; i < 10; i++)
   {
      uchar tmp[1];
      tmp[0] = i;
      ArrayCopy(result.byte, tmp, ArraySize(result.byte));
   }
   return result;
}
//+------------------------------------------------------------------+
void OnStart()
{
   uchar arr[];
   for(int i = 0; i < 3; i++)
   {
      ArrayCopy(arr, f().byte, ArraySize(arr));
   }
   
   ArrayPrint(arr); // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

}
//+------------------------------------------------------------------+

使用这种对结构域的访问是很方便的，....哪里会有隐患--错误/误差？

 
Igor Makanu:

我惊讶地发现，即使这个结构被作为一个函数结果返回，也可以访问结构字段。

这段代码工作正常（我们在函数中填充结构，然后将函数的结果复制到一个字节数组中）。

使用这种对结构域的访问是很方便的，....哪里会有陷阱/缺陷/错误？

这种事情））没有任何bug。

 ArrayCopy(arr, (f()).byte, ArraySize(arr))

所以更正确的说法是来自歌剧(。)(。)

我也不明白复制到字节数组中有什么关系。这只是为了从返回的结构中访问数据
 
Alexandr Andreev:
 这只是在访问返回结构的数据

是的，但令人困惑的是，我在访问字节字段时没有中间变量，直接访问f()函数的结果。

所以我在等着接应

f().byte
 
Igor Makanu:

是的，但令人困惑的是，我在访问字节字段时没有中间变量，直接访问f()函数的结果。

所以我在等着接应

几年来，它一直很稳定。

 
Alexandr Andreev:

几年来一直很稳定。

好的，谢谢你!

1...81828384858687888990919293949596
新评论