巴解组织。应用问题 - 页 5

新评论
 

不知何故，多用性是否影响处理器处理代码的速度(2011.04.04 21:58)的问题完全没有被关注。

如果问题看起来不正确，很傻，等等。- 那就这么写吧。

 
Yedelkin:

不知何故，多用性是否影响处理器的代码处理速度(2011.04.04 21:58)的问题完全没有被关注。

如果问题看起来不正确，很傻，等等。- 就这样写吧。

这个问题是完全合乎逻辑的，答案是不，它 没有。

2011.04.09 10:21:31     Черновик 31 (GBPUSD,H1) время c обёртками=1656
2011.04.09 10:21:29     Черновик 31 (GBPUSD,H1) время без обёртки=1766



class CA
  {
private:
   uint              func1(int count){return(func2(count));};
   uint              func2(int count){return(func3(count));};
   uint              func3(int count){return(func4(count));};
   uint              func4(int count){return(func5(count));};
   uint              func5(int count){return(func6(count));};
   uint              func6(int count){return(func7(count));};
   uint              func7(int count){return(func8(count));};
   uint              func8(int count){return(func9(count));};
   uint              func9(int count)
     {
      uint start=GetTickCount();
      double a=123456.4567879;double b=234.568;double temp;
      for(int i=0;i<count;i++)
        {
         if(i%2==0)temp=a/b;
         else temp=a*b;
        }
      return(GetTickCount()-start);
     };
public:
                     CA(void){};
                    ~CA(void){};
   uint              func(int count){return(func1(count));};

  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
          Print("время без обёртки=",  func(100000000));
   CA a; Print("время c обёртками=",a.func(100000000));
  }
//+------------------------------------------------------------------+
uint func(int count)
  {
   uint start=GetTickCount();
   double a=123456.4567879;double b=234.568;double temp;
   for(int i=0;i<count;i++)
     {
      if(i%2==0)temp=a/b;
      else temp=a*b;
     }
   return(GetTickCount()-start);
  }
//+------------------------------------------------------------------+
 

我知道了!好吧，你给了我很多鼓励!现在我将加倍享受盖章嵌套法的乐趣 :)

Urain，谢谢你的例子!虽然你没有编程经验，但有时很难自己猜测，为其检查和编写正确的代码。而在这里，一切都很清楚，可以理解。

 

问题。一个子类的实例可以删除自己吗？换句话说，这样的构架会起作用吗？

class C_A
  {
public:
                     C_A(){};
                    ~C_A(){};
   void Del(C_A *p)
     {
      if(CheckPointer(p)==POINTER_DYNAMIC)
        {
         delete p;
        }
     }
  };
class C_B : public C_A
  {
public:
                     C_B(){};
                    ~C_B(){};
  };
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   C_A *pointer=new C_B;
   pointer.Del(pointer);
  }
编译器并没有抱怨这个结构。
 
Yedelkin:

问题。一个子类的实例可以删除自己吗？换句话说，这个建筑能不能用？

编译器并没有抱怨这个结构。

如果我理解正确，我不喜欢指针（我也不经常使用它们，特别是在MQL5中），孩子应该是这样的

class C_B : public C_A
{
public:
                     C_B(){};
                    ~C_B(){};

   void Del(C_B *p)
     {
      if(CheckPointer(p)==POINTER_DYNAMIC)
        {
         delete p;
        }
     }
};

因此，该应用程序将看起来像这样

void OnStart()
{
C_B *pointer=new C_B;
pointer.Del(pointer);
}

PS

编译器漏掉的是一个错误（或编译器的一个特点）吗？

当然，我们可以假设子孙后代通过了我们需要的类，但这两个类的结构和功能可能有很大的不同。那么接下来会发生什么？

C_A *pointer=new C_B;
 

而在使用这样的初始代码时，尽管所有的编译器检查都已通过（甚至没有提到任何可能的问题），但根本就出现了内存泄露的情况

void OnStart()
{
C_B *pointer=new C_B;
pointer.Del(pointer);
}

下面是结果（我明白，由于内存泄漏，指针对象没有被正确删除）。

2011.04.09 19:21:07    Forum (EURUSD,D1)    16 bytes of leaked memory
2011.04.09 19:21:07    Forum (EURUSD,D1)    1 object of type C_B left
2011.04.09 19:21:07    Forum (EURUSD,D1)    1 undeleted objects left
 
Interesting:

如果我理解正确的话，我不喜欢指针（我也不经常使用它们，特别是在MQL5中），那么后代应该是这样的

看。我在父类中声明了带有修饰符public的void Del(C_A *p)方法。所以，子类已经完全继承了这个方法。所以我不需要在子类中重新声明同一个方法。至于 
C_A *pointer=new C_B;
我从俄罗斯方块中得到了这个想法，而且对我来说效果很好。当然，直接使用这条线路是不对的，但它非常适用于与俄罗斯方块中解决的类似目的。
 
Yedelkin:

不知何故，多用性是否影响处理器的代码处理速度(2011.04.04 21:58)的问题完全没有被关注。

如果问题看起来不正确，很傻，等等。- 就写吧。

答案是逻辑 -- 基元越简单、越符合逻辑，优化器的效率就越高。

最主要的是不要做得太过火 :)

 

稍微修改了一下脚本代码。

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class C_A
  {
public:
                     C_A(){ Print("Запущен класс С_А"); };
                    ~C_A(){Print("Закрыт класс С_А");};
   void Del(C_A *p)
     {
      if(CheckPointer(p)==POINTER_DYNAMIC)
        {
         delete p;
         Print("Удалён объект p");
        }
     }
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class C_B : public C_A
  {
public:
                     C_B(){ Print("Запущен класс С_В"); };
                    ~C_B(){Print("Закрыт класс С_В");};
  };
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   C_A *pointer=new C_B;
   if(pointer!=NULL) Print("указатель pointer проинициализирован");
   pointer.Del(pointer);
  }

输出 

EL      0       ttttttttttttt (EURUSD,M1)       15:08:27        Запущен класс С_А
MS      0       ttttttttttttt (EURUSD,M1)       15:08:27        Запущен класс С_В
DJ      0       ttttttttttttt (EURUSD,M1)       15:08:27        указатель pointer проинициализирован
IH      0       ttttttttttttt (EURUSD,M1)       15:08:27        Закрыт класс С_В
CG      0       ttttttttttttt (EURUSD,M1)       15:08:27        Закрыт класс С_А
RO      0       ttttttttttttt (EURUSD,M1)       15:08:27        Удалён объект p
 
Yedelkin:
看。我在父类中声明了带有修饰符public的void Del(C_A *p)方法。所以子类已经完全继承了这个方法。所以我不需要在子类中重新声明同一个方法。至于这个想法，我是从俄罗斯方块中得到的，对我来说效果非常好。当然，直接使用这个字符串是不正确的，但它非常适用于与俄罗斯方块中解决的类似目的。

即使假设祖先中的void Del(C_A *p)足以删除任何后裔指针，我也不明白为什么使用

C_A *pointer=new C_B;

PS

我可以想象，唯一需要这种方法的地方是创建一个由同一类的后代组成的杂项对象的数组（或者，将 "基 "类类型的参数传入一个函数或过程）。

123456789101112...19
新评论