How to avoid repetitive code sections during initialisation - General

Igor Makanu 2019.08.31 18:05 #211

Vladimir Simakov:

1. new operator returns a pointer, of course, developers made a mess with implicit dereferencing, so your version works, but it's better not to get hung up on undocumented things.

2. Of course, we don't have C++, but it's very similar, so initialization lists (I don't know about efficiency) are kosher.

Checked, yes your option works, and logically it's more correct:

interface IStrategy
  {
   void Algorithm()  { Print("Это не должно вызываться!!!"); }
  };
//+------------------------------------------------------------------+
class Strategy_1 : public IStrategy
  {
public:
                     Strategy_1()   { Print(__FUNCTION__); }
   void              Algorithm()    { Print(__FUNCTION__); }
  };
//+------------------------------------------------------------------+
class Strategy_2 : public IStrategy
  {
public:
                     Strategy_2()   { Print(__FUNCTION__); }
   void              Algorithm()    { Print(__FUNCTION__); }
  };
//+------------------------------------------------------------------+
class Context
  {
public:
   IStrategy         *s;
                     Context(IStrategy *_strategy) { Print(__FUNCTION__); s = _strategy;              }
                    ~Context()                     { delete s;                                        }
   void              GetStrategy()                 { s.Algorithm();                                   }
  };
//+------------------------------------------------------------------+
Context c1(new Strategy_1);
Context c2(new Strategy_2);
//+------------------------------------------------------------------+
void OnStart()
  {
   c1.GetStrategy();
   c2.GetStrategy();
   
   c1.s.Algorithm();
  }
//+------------------------------------------------------------------+

2019.08.31 22:07:35.196 tst (EURUSD,H1) Strategy_1::Strategy_1

2019.08.31 22:07:35.196 tst (EURUSD,H1) Context::Context

2019.08.31 22:07:35.196 tst (EURUSD,H1) Strategy_2::Strategy_2

2019.08.31 22:07:35.196 tst (EURUSD,H1) Context::Context

2019.08.31 22:07:35.196 tst (EURUSD,H1) Strategy_1::Algorithm

2019.08.31 22:07:35.196 tst (EURUSD,H1) Strategy_2::Algorithm

2019.08.31 22:07:35.197 tst (EURUSD,H1) Strategy_1::Algorithm

The pointer and the object created at initialization were not lost, and the method in the interface did not substitute the methods of the classes 1 and 2 - everything seems to work as planned

Any questions from newcomers Features of the mql5 Errors, bugs, questions

Igor Makanu 2019.08.31 21:49 #212

How can I avoid repetitive code sections during initialisation? - in the constructor you cannot

class MyClass
{
   public:
      MyClass()         {Print("Create MyClass");}
};

interface IStrategy
  {
   void Algorithm()  { Print("Это не должно вызываться!!!"); }
  };
//+------------------------------------------------------------------+
class Strategy_1 : public IStrategy
  {
  private:
  MyClass   *m;
public:
                     Strategy_1()   { Print(__FUNCTION__); }
   void              Algorithm()    { if(m==NULL) m = new MyClass; else { } } 
  };
//+------------------------------------------------------------------+
class Strategy_2 : public IStrategy
  {
  private:
  MyClass   *m;
public:
                     Strategy_2()   { Print(__FUNCTION__); }
   void              Algorithm()    { if(m==NULL) m = new MyClass; else { } }
  };
//+------------------------------------------------------------------+
class Context
  {
private:
   IStrategy         *s;
public:
                     Context(IStrategy *_strategy) { Print(__FUNCTION__); s = _strategy;              }
                    ~Context()                     { delete s;                                        }
   void              GetStrategy()                 { s.Algorithm();                                   }
  };
//+------------------------------------------------------------------+
Context c1(new Strategy_1);
Context c2(new Strategy_2);
//+------------------------------------------------------------------+
void OnStart()
  {
   c1.GetStrategy();
   c2.GetStrategy();
  }
//+------------------------------------------------------------------+

Vladimir Simakov 2019.08.31 22:45 #213

Igor Makanu:

How can I avoid repetitive code sections during initialisation? - in the constructor, you can't

Instead of interface you make an ordinary class. You put *m there and make a bool SomeMethod {if(CheckPointer(m)) return false; m=new...; return true;}

In Algoritm if (SomeMethod()) ...

Igor Makanu 2019.08.31 23:41 #214

Vladimir Simakov:
Instead of interface, you make a regular class. There you put *m and make method bool SomeMethod {if (CheckPointer(m)) return false; m=new...; return true;}

In Algoritm if (SomeMethod()) ...

No, I need the interfes - it's very cool that I won't need to pull everything at every tick - I'll make one call of one strategy per one tick - in general I like config of all this so far, it seems it was necessary to solve my problem this way:

class MyClass
{
   public:
      MyClass()         {Print("Create MyClass");}
};

interface IStrategy
  {
   void Algorithm()  { Print("Это не должно вызываться!!!"); }
  };
  
class CStrategy : public IStrategy
{
protected:
   MyClass  *m;
   void Init()   {  m=new MyClass; }
};
//+------------------------------------------------------------------+
class Strategy_1 : public CStrategy
  {
public:
                     Strategy_1()   { Print(__FUNCTION__); }
   void              Algorithm()    { if(m==NULL) Init(); else { } } 
  };
//+------------------------------------------------------------------+
class Strategy_2 : public CStrategy
  {
public:
                     Strategy_2()   { Print(__FUNCTION__); }
   void              Algorithm()    { if(m==NULL) Init(); else { } }
  };
//+------------------------------------------------------------------+
class Context
  {
private:
   IStrategy         *s;
public:
                     Context(IStrategy *_strategy) { Print(__FUNCTION__); s = _strategy;              }
                    ~Context()                     { delete s;                                        }
   void              GetStrategy()                 { s.Algorithm();                                   }
  };
//+------------------------------------------------------------------+
Context c1(new Strategy_1);
Context c2(new Strategy_2);
//+------------------------------------------------------------------+
void OnStart()
  {
   c1.GetStrategy();
   c2.GetStrategy();
  }
//+------------------------------------------------------------------+

Adding a breakeven option Which DC should I Help out anyone who

Igor Makanu 2019.09.01 12:02 #215

I tweaked my example a bit - it works, but it should look like this:

//+------------------------------------------------------------------+
interface IStrategy
{  void Algorithm()                 {Print("Это не должно запускаться!!!"); } };
//+------------------------------------------------------------------+
class CStrategy : public IStrategy
{
protected:
   int x;
public:
   virtual void Algorithm()         {Print("Это не должно запускаться!!!"); } };
//+------------------------------------------------------------------+
class CStrategy_01:public CStrategy
{
public:
   CStrategy_01()                   {Print(__FUNCTION__);  x = 01;         }
   void Algorithm()                 {Print(__FUNCTION__,", x = ",x);       } };
//+------------------------------------------------------------------+
class CStrategy_02:public CStrategy
{
public:
   CStrategy_02()                   {Print(__FUNCTION__);   x = 02;        }
   void Algorithm()                 {Print(__FUNCTION__,", x = ",x);       } };
//+------------------------------------------------------------------+
class Context
{
private:
   IStrategy         *s;
public:
   Context(IStrategy *_strategy)    { Print(__FUNCTION__); s = _strategy;  }
   ~Context()                       { delete s;                            }
   void              GetStrategy()  { s.Algorithm();                       } };
//+------------------------------------------------------------------+
Context c1(new CStrategy_01);
Context c2(new CStrategy_02);
//+------------------------------------------------------------------+
void OnStart()
{  c1.GetStrategy();
   c2.GetStrategy(); }
//+------------------------------------------------------------------+



0	15:57:17.100	tst EURUSD,H1: CStrategy_01::CStrategy_01
0	15:57:17.100	tst EURUSD,H1: Context::Context
0	15:57:17.100	tst EURUSD,H1: CStrategy_02::CStrategy_02
0	15:57:17.100	tst EURUSD,H1: Context::Context
0	15:57:17.100	tst EURUSD,H1: initialized
0	15:57:17.100	tst EURUSD,H1: CStrategy_01::Algorithm, x = 1
0	15:57:17.100	tst EURUSD,H1: CStrategy_02::Algorithm, x = 2

but if I remove the body of theCStrategy::Algorithm(void) method, there will be an error: 'Algorithm' -the function must have a body

Why is it an error? - because I declare the CStrategy::Algorithm(void) method with the modifier virtual

Signal with CiMA getting [WARNING CLOSED!] Any newbie Learning and writing together

Vladimir Simakov 2019.09.01 12:09 #216

Igor Makanu:

I tweaked my example a bit - it works, but it should look like this:

but if I remove the body of the CStrategy::Algorithm(void) method, there will be an error: 'Algorithm' - the function must have a body

Why is it an error? - because I declare the CStrategy::Algorithm(void) method with the modifier virtual

An abstract method must be implemented in the descendants. Once again, there is no need for interface here.

Vladimir Simakov 2019.09.01 12:11 #217

virtual void Algoritm()=0;

Try this.

Vladimir Simakov 2019.09.01 12:15 #218

Vladimir Simakov:
virtual void Algoritm()=0;

Try this.

No, that won't work either. If you declare an abstraction, be kind enough to implement it.

Igor Makanu 2019.09.01 12:25 #219

Vladimir Simakov:
No, that won't work either. If you declare an abstraction, be kind enough to implement it.

I think the compiler perceives the Algorithm() method from the interface and the declared virtual void Algorithm() as different methods because of the virtual modifier

Vladimir Simakov:
An abstract method must be implemented in descendants. Once again, there's no need to implement it.

I need interfaces because it is convenient for me to declare different behaviour for 6 strategies depending on Expert Advisor settings (there are not so many strategies but order systems)

right now:

class CGrid {
private:
   int               StrategyCount;
   IStrategy         *Strategy[];
public:
   CGrid(int eamagicnumber, SSettingsForOrder &settingstrategy[]);
   ~CGrid(); };
//+------------------------------------------------------------------+
void CGrid::CGrid(int eamagicnumber, SSettingsForOrder &settingstrategy[]) {
   StrategyCount = ArraySize(settingstrategy);
   ArrayResize(Strategy, StrategyCount);
   for(int i = 0; i < StrategyCount; i++) {
      settingstrategy[i].magicnumber = i+eamagicnumber;
      switch(settingstrategy[i].dealtype) {
      case NONE                  :  Strategy[i] = new CNONE(settingstrategy[i]);                   break;
      case BUY                   :  Strategy[i] = new CBUY(settingstrategy[i]);                    break;
      case ReOpenBUY             :  Strategy[i] = new CReOpenBUY(settingstrategy[i]);              break;
      case ReversBUYToSellOnly   :  Strategy[i] = new CReversBUYToSellOnly(settingstrategy[i]);    break;
      case ReversBUYAlwaysRevers :  Strategy[i] = new CReversBUYAlwaysRevers(settingstrategy[i]);  break;
      case SELL                  :  Strategy[i] = new CSELL(settingstrategy[i]);                   break;
      case ReOpenSELL            :  Strategy[i] = new CReOpenSELL(settingstrategy[i]);             break;
      case ReversSELLToBuyOnly   :  Strategy[i] = new CReversSELLToBuyOnly(settingstrategy[i]);    break;
      case ReversSELLAlwaysRevers:  Strategy[i] = new CReversSELLAlwaysRevers(settingstrategy[i]); break; } } }

I want to minimize the body of Algorithm() methods - if I write the base class correctly - in my example, class CStrategy, then the Algorithm() itself will contain 5-10 lines at most

How should I write this code without an interface? - Now everything is brief and there will only be left to pull the algorithms themselves strategies every tick or less frequently

Mt4 End of support. Questions on OOP (Object Errors, bugs, questions

Vladimir Simakov 2019.09.01 12:35 #220

как этот код без интерфейса написать? - сейчас все кратко и останется только дергать сами алгоритмы стратегий каждый тик или реже

I'll show you tonight. I'm on my phone right now.

Questions on OOP in MQL5 - page 22