MQL5中的OOP问题

Alexandr Andreev 2020.06.13 17:25 #811

Igor Makanu:

初始化什么并不重要，甚至是int--任何数字都可以调用这个构造函数。

我选择0.0是为了避免误印--任何数字，即0.0，它比123更难书写和误印

(双)0

但也不是这样的))))，刚才是正常看代码，还有一种方法是非正常看))

Igor Makanu 2020.06.13 17:26 #812

Alexandr Andreev:

(双)0

不

我只写了0.0--没有预期的其他数字--构造函数中甚至没有一个变量

一般来说，作为一个时尚的作者的风格，也许不是最好的

Vladimir Simakov 2020.06.13 17:35 #813

Alexandr Andreev:

重点不是x），而是接收器上可能有一个浮点，指定0.0也不可靠。

0.0对编译器来说是一个明确的双倍数，浮点数将是0.f。

Alexandr Andreev 2020.06.13 17:40 #814

Vladimir Simakov:
0.0对编译器来说是明确的双倍数，浮点数将是0.f。

贷）。

Aleksey Mavrin 2020.06.13 20:27 #815

虽然 "50岁以上的问题 "部分是开放的，但让我把自己的问题插进铸模的主题。

- 在容错或不冗余方面，有哪些方法可以改进代码？

-CheckPointer()!=POINTER_INVALID检查是否有必要？还是绝对没有必要？解释一下原因。

- 带到非const，这样就有可能调用非const方法。能否在比较方法中直接调用非常量方法？即摆脱黄色突出显示的 const？

#include <ChartObjects\ChartObjectsShapes.mqh>

class CChartObjectRectangleX : public CChartObjectRectangle
  {
public:

   void CChartObjectRectangleX(){};      
   virtual int       Compare(const CObject *node,const int mode=0) const 
   {
   CChartObjectRectangleX *n=NULL;
   const CChartObjectRectangleX*nc=dynamic_cast<const CChartObjectRectangleX*>(node);
   if(nc!=NULL)
   n=(CChartObjectRectangleX *) nc;
   if(n!=NULL) {
     if(mode==0) return CompareDate(n); 
     if(mode==1) return CompareValue(n); }return 0;    }
 
   virtual int       CompareDate( CChartObjectRectangleX *node) const { 
   //if(node!=NULL) 
      return (this.Time(1)-node.Time(1)); return 0;    }
    virtual int       CompareValue( CChartObjectRectangleX *node) const { 
   //if(node!=NULL) 
      return ((this.Price(1)-node.Price(1))*10/Point()); return 0;    }
};

Vladimir Simakov 2020.06.13 21:59 #816

Aleksey Mavrin:

虽然 "50岁以上的问题 "部分是开放的，但让我把自己的问题插进铸模的主题。

- 在容错或不冗余方面，有哪些方法可以改进代码？

- CheckPointer()!=POINTER_INVALID检查是否有必要？还是绝对没有必要？解释一下原因。

- 带到非const，这样就有可能调用非const方法。能否在比较方法中直接调用非常量方法？即摆脱黄色突出显示的 const？

class CChartObjectRectangleX : public CChartObjectRectangle
  {
public:
   virtual int       Compare(const CObject *node,const int mode=0) const
   {
   const CChartObjectRectangleX *n=dynamic_cast<const CChartObjectRectangleX*>(node);
   return !n?0: mode==0?CompareDate(n):CompareValue(n);}
   
   virtual int CompareDate(const CChartObjectRectangleX *node) const {return !node?0:int(Time(1)-node.Time(1));}
   virtual int CompareValue(const CChartObjectRectangleX *node) const {return !node?0:(int)MathRound(((Price(1)-node.Price(1))*10/Point()));}
};

这和你的有点一样，只是字母比较少。这是一个品味问题，谁更喜欢它，但我已经删除了额外的变量（编译器可能也会在优化框架内删除它）。

关于我的！节点检查。必须用CheckPointer(node)==POINTER_INVALID来代替，但这是一个开销--一个函数调用。即使它是内联的，它至少也是在取消引用和检查状态标志。如果只是库或具体的，你写的程序将使用比较方法，最好！节点和代码上的无效指针。如果你懒得注意指针，或者这是一个为弱者准备的库，只有CheckPointer(node)==POINTER_INVALID。

如果你删除了你强调的const指定符，你就不能从一个常量对象中调用这些方法。

UPD：突出显示的检查可以被删除，因为它在被调用的方法中。

Alexandr Andreev 2020.06.13 22:33 #817

Aleksey Mavrin:

虽然 "50岁以上的问题 "部分是开放的，但让我把自己的问题插进铸模的主题。

- 在容错或不冗余方面，有哪些方法可以改进代码？

- CheckPointer()!=POINTER_INVALID检查是否有必要？还是绝对没有必要？解释一下原因。

- 带到非const，这样就有可能调用非const方法。是否有可能在比较方法中直接调用一个非常量方法？即摆脱黄色突出显示的 const？

这个想法是要为同一个函数写两个方法，分别带有和不带有const体--说得不好听--不值得))))。

但遇到两种方法的概率接近于零....。因为CChartObjectRectangle::Price 存在的可能性--在正文中没有const--我认为是不太可能的。

从外部调用这个函数没有任何效果。也就是说，const只对内部函数起作用，并确保没有任何东西被写入对象的内存中（没有改变变量的值）。换句话说，你不能在常态下调用Set(a)。通常，在一些混乱的情况下，为了确保这个函数不会覆盖任何东西，你可以快速安排这些常数（尽管这可能是我的删除）。

考虑到consts应该在没有得到)))) 的情况下随便塞给别人，以方便以后检查什么。

CheckPointer()!=POINTER_INVALID是否需要检查？

而为什么不....做一个 bool Check(<template> &T) { retun CheckPointer(T)!=POINTER_INVALID } 编译器应该让它尽可能的简单。而且它将看起来更棒。

它的速度更快。

int a[1000];
for (int i=0; i<ArraySize(a); i++)....
или
for (int i=ArraySize(a); i>=0; i--)....
дак вот разницы не должно быть вообще

好吧，我并没有改变什么。

template<typename T>
bool Check(T *a) {return CheckPointer(a)!=POINTER_INVALID;};

class CChartObjectRectangleX : public CChartObjectRectangle
  {
  #define  ME CChartObjectRectangleX
public:
   void ME(){};      
   virtual int       Compare(const CObject *node,const int mode=0) const 
   {
   const ME*nc=dynamic_cast<const ME*>(node);
   return Check(nc)?mode==0?CompareDate(nc):CompareValue(nc):0;
   } 
   virtual int       CompareDate(const ME *node) const            {return (this.Time(1)-node.Time(1));}
   virtual int       CompareValue(const ME *node) const           {return ((this.Price(1)-node.Price(1))*10/Point()); }
 #undef  ME
};

这就是你所有的代码。

Alexandr Andreev 2020.06.13 22:33 #818

Vladimir Simakov:

它似乎与你的相同，只是字母较少。因此，这是一个品味问题，但我删除了额外的变量（很可能，编译器会将其作为优化的一部分而删除）。

关于我的！节点检查。必须用CheckPointer(node)==POINTER_INVALID来代替，但这是一个开销--一个函数调用。即使它是内联的，它至少也是在取消引用和检查状态标志。如果只是库或具体的，你写的程序将使用比较方法，最好！节点和代码上的无效指针。如果你懒得注意指针，或者这是一个为弱者准备的库，只有CheckPointer(node)==POINTER_INVALID。

如果你删除了const指定符，你就不能从一个常量对象中调用这些方法。

我花了很长时间才打开这个标签

我想4年的大学生活并没有给我增加多少知识（解释是在垃圾堆里落后）。

Alexandr Andreev 2020.06.13 23:13 #819

由于基类没有对输入参数的引用，所以没有宪法的变体也会正确工作，尽管这不是一个非常聪明的风格

#include <ChartObjects\ChartObjectsShapes.mqh>

template<typename T>
bool Check(T *a) {return CheckPointer(a)!=POINTER_INVALID;};

class CChartObjectRectangleX : public CChartObjectRectangle
  { #define  ME CChartObjectRectangleX
public: 
   void ME(){};      
   virtual int       Compare(CObject *node,int mode=0) 
   {
   ME*nc=dynamic_cast<ME*>(node);
   return Check(nc)?mode==0?CompareDate(nc):CompareValue(nc):0;
   } 
   virtual int       CompareDate(ME *node)             {return (this.Time(1)-node.Time(1));}
   virtual int       CompareValue(ME *node)            {return ((this.Price(1)-node.Price(1))*10/Point()); }
 #undef  ME
};

Alexandr Andreev 2020.06.13 23:17 #820

也是同一代码的一个变体。

template<typename T>
bool Check(T *a) {return CheckPointer(a)!=POINTER_INVALID;};

class CChartObjectRectangleX : public CChartObjectRectangle
  { #define  ME CChartObjectRectangleX
public: 
   void ME(){};      
   virtual int       Compare(CObject *node,int mode=0)      {return Check(node)?mode==0?CompareDate(node):CompareValue(node):0;} 
   virtual int       CompareDate(CObject *node)             {return (  Time(1)-dynamic_cast<ME*>(node).Time(1));}
   virtual int       CompareValue(CObject *node)            {return ((Price(1)-dynamic_cast<ME*>(node).Price(1))*10/Point()); }
 #undef  ME
};

这是与常数相同的一个。

template<typename T>
bool Check(T *a) {return CheckPointer(a)!=POINTER_INVALID;};

class CChartObjectRectangleX : public CChartObjectRectangle
  { #define  ME CChartObjectRectangleX
public: 
   void ME(){};      
   virtual int       Compare(CObject const *node,int const mode=0)   const{return Check(node)?mode==0?CompareDate(node):CompareValue(node):0;} 
   virtual int       CompareDate(CObject const *node)                const{return (  Time(1)-dynamic_cast<const ME*>(node).Time(1));}
   virtual int       CompareValue(CObject const *node)               const{return ((Price(1)-dynamic_cast<const ME*>(node).Price(1))*10/Point()); }
 #undef  ME
};

MQL5中的OOP问题 - 页 82