Там да, больше акцент на этом.
Но востребованность mql5 не особо высока.
Я к тому, что может ООП для mql4 использовать для построения приложения, а все расчеты и логику делать на C++?

А насколько вообще актуально для mql4?
Могу рассуждать чисто теоретически, что скорость исполнения mql скриптов довольно низкая, а если использовать ООП, то скорее всего это еще больше тормозов. Плюс ООП применяется, как раз для более глобальных и сложных систем(советников и т.д.), то есть грубо говоря умножаем тормоза на тормоза  

Если исходник не нужен, рабочая версия тут www.forexfactory.com/showthread.php?t=513671

//+------------------------------------------------------------------+
//|                                                      Candler.mq4 |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

input int slippage  = 20;
input int sl  = 200;
input int tp  = 500;
input double lot = 0.1;
input double AvgBar  = 70;
input double Delta  = 35;
extern bool IsShadow  = false; // true - по high/low, false - по open/close
input int Count  = 3;
datetime New_Time=0;
int res=0;

extern int Magic = 999;
enum _TypeOrders{ 
   market,
   limit,
   stop
};
extern _TypeOrders TypeOrder = market;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Candles()
  {
   int count = 0;
   double CandleHigh = 0, CandleLow = 0, dl = 0, high = 0, low = 0, open = 0, close = 0, lastopen = 0, lastclose = 0;
   
   for(int i=1;i<=Count;i++)
     {  	 
         open = Open[i];
   		close = Close[i]; 
   		lastopen = Open[1];
   		lastclose = Close[1];
		      if(IsShadow)
		      {
   		      high = High[i];
   		      low = Low[i];
   		      if(i == 1)
         		  {
         		      CandleHigh = High[1];
      		         CandleLow = Low[1];
         		  }
		      }
		      else
		      {
		         if(i == 1)
         		  {
         		      CandleHigh = lastopen;
         		      CandleLow = lastclose;
         		      
         		      if(lastclose > lastopen)
      		         {
      		            CandleHigh = lastclose;
         		         CandleLow = lastopen;
      		         }
         		  }
         		  
         		   high = open;
      		      low = close;
      		         if(close > open)
      		         {
      		            high = close;
         		         low = open;
      		         }
		      }   
     
		if(MathAbs(CandleHigh-high)/Point<=Delta && MathAbs(CandleLow-low)/Point<=Delta && MathAbs(high-low)/Point>=(AvgBar-Delta) && MathAbs(high-low)/Point<=(AvgBar+Delta))
		{
			 count++;
		}
   		CandleHigh = high;
   		CandleLow = low;
      }
      
   if(count == Count && lastopen > 0 && lastclose > 0)
   {
      if(lastclose > lastopen) return 1;
      else return 2;
   }
	
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
      if(New_Time!=Time[0])
       {
         res = Candles();
         if(res > 0 && CountOrders(-1) == 0)
         {
               if(res == 1) PutOrder(OrderPlace(1), Ask);
               if(res == 2) PutOrder(OrderPlace(2), Bid);
               New_Time=Time[0];
         }
      }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountOrders(int type)
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type) count++;
            if(type == -1) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OrderPlace(int bs) 
  {  
   string OrdType = EnumToString(TypeOrder);
   if (OrdType == "market") 
   {
      if(bs == 1) return 0;
      if(bs == 2) return 1;
   } 
   if (OrdType == "limit") 
   {
      if(bs == 1) return 2;
      if(bs == 2) return 3;
   } 
   if (OrdType == "stop") 
   {
      if(bs == 1) return 4;
      if(bs == 2) return 5;
   }
   return -1;  
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type, double price)
  {
   int r=0;
   color clr=Green;
   double s=0,t=0;   

   if(type==-1) return;

   if(type==1 || type==3 || type==5)
     {
      clr=Red;
      if(sl>0) s=NormalizeDouble(price+sl*Point,Digits);
      if(tp>0) t=NormalizeDouble(price-tp*Point,Digits);
     }

   if(type==0 || type==2 || type==4)
     {
      clr=Blue;
      if(sl>0) s=NormalizeDouble(price-sl*Point,Digits);
      if(tp>0) t=NormalizeDouble(price+tp*Point,Digits);
     }

   r=OrderSend(NULL,type,lot,NormalizeDouble(price,Digits),slippage,s,t,"",Magic,0,clr);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+    

А вот если бы ТЗ сразу целиком и полностью    

//+------------------------------------------------------------------+
//|                                                      Candler.mq4 |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

input int slippage  = 20;
input int sl  = 200;
input int tp  = 500;
input double lot = 0.1;
input double AvgBar  = 80;
input double Delta  = 25;
input int Count  = 3;
datetime New_Time=0;

extern int Magic = 999;
enum _TypeOrders{ 
   market,
   limit,
   stop
};
extern _TypeOrders TypeOrder = market;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Candles(int type)
  {
   int count = 0;
   double CandleHigh = 0, CandleLow = 0;
   
   for(int i=1;i<=Count;i++)
     {
     
      if(i == 1)
		  {
		      CandleHigh = High[1];
		      CandleLow = Low[1];
		  }     
     
		if(MathAbs(CandleHigh-High[i])/Point<=Delta && MathAbs(CandleLow-Low[i])/Point<=Delta && MathAbs(High[i]-Low[i])/Point>=(AvgBar-Delta) && MathAbs(High[i]-Low[i])/Point<=(AvgBar+Delta))
		{		  
		  if(Close[i]>Open[i] && type==1)//bulls
			{
			  count++;
			}

		  if(Close[i]<Open[i] && type==2)//bear
			{
			 count++;
			}
		}
		CandleHigh = High[i];
		CandleLow = Low[i];
     }
	
   return(count);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
      if(New_Time!=Time[0])
       {
         if(Candles(1) == Count && CountOrders(0) < 1 && CountOrders(2) < 1 && CountOrders(4) < 1)
         {
               PutOrder(OrderPlace(1), Ask);
               New_Time=Time[0];
         }
         if(Candles(2) == Count && CountOrders(1) < 1 && CountOrders(3) < 1 && CountOrders(5) < 1)
         {
               PutOrder(OrderPlace(2), Bid);
               New_Time=Time[0];        
         }
      }
  
   Comment("\n Bulls Candles: ",Candles(1),
           "\n Bears Candles: ",Candles(2));

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountOrders(int type)
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OrderPlace(int bs) 
  {  
   string OrdType = EnumToString(TypeOrder);
   if (OrdType == "market") 
   {
      if(bs == 1) return 0;
      if(bs == 2) return 1;
   } 
   if (OrdType == "limit") 
   {
      if(bs == 1) return 2;
      if(bs == 2) return 3;
   } 
   if (OrdType == "stop") 
   {
      if(bs == 1) return 4;
      if(bs == 2) return 5;
   }
   return -1;  
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type, double price)
  {
   int r=0;
   color clr=Green;
   double s=0,t=0;   

   if(type==-1) return;

   if(type==1 || type==3 || type==5)
     {
      clr=Red;
      if(sl>0) s=NormalizeDouble(price+sl*Point,Digits);
      if(tp>0) t=NormalizeDouble(price-tp*Point,Digits);
     }

   if(type==0 || type==2 || type==4)
     {
      clr=Blue;
      if(sl>0) s=NormalizeDouble(price-sl*Point,Digits);
      if(tp>0) t=NormalizeDouble(price+tp*Point,Digits);
     }

   r=OrderSend(NULL,type,lot,NormalizeDouble(price,Digits),slippage,s,t,"",Magic,0,clr);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+    

Набросок
Похоже все равно нужен параметр средняя длина свечи, а то открывает ночью на флэте слишком много  

//+------------------------------------------------------------------+
//|                                                      Candler.mq4 |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

input int slippage  = 20;
input int sl  = 200;
input int tp  = 300;
input double lot = 0.1;
input double Delta  = 25;
input int Count  = 3;
datetime New_Time=0;

extern int Magic = 999;
enum _TypeOrders{ 
   market,
   limit,
   stop
};
extern _TypeOrders TypeOrder = market;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Candles(int type)
  {
   int count = 0;
   double CandleHigh = 0, CandleLow = 0;
   
   for(int i=1;i<=Count;i++)
     {
     
      if(i == 1)
		  {
		      CandleHigh = High[1];
		      CandleLow = Low[1];
		  }     
     
		if(MathAbs(CandleHigh-High[i])/Point<=Delta && MathAbs(CandleLow-Low[i])/Point<=Delta)
		{		  
		  if(Close[i]>Open[i] && type==1)//bulls
			{
			  count++;
			}

		  if(Close[i]<Open[i] && type==2)//bear
			{
			 count++;
			}
		}
		CandleHigh = High[i];
		CandleLow = Low[i];
     }
	
   return(count);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
      if(New_Time!=Time[0])
       {
         if(Candles(1) == Count && CountOrders(0) < 1 && CountOrders(2) < 1 && CountOrders(4) < 1)
         {
               PutOrder(OrderPlace(1), Ask);
               New_Time=Time[0];
         }
         if(Candles(2) == Count && CountOrders(1) < 1 && CountOrders(3) < 1 && CountOrders(5) < 1)
         {
               PutOrder(OrderPlace(2), Bid);
               New_Time=Time[0];        
         }
      }
  
   Comment("\n Bulls Candles: ",Candles(1),
           "\n Bears Candles: ",Candles(2));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountOrders(int type)
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OrderPlace(int bs) 
  {  
   string OrdType = EnumToString(TypeOrder);
   if (OrdType == "market") 
   {
      if(bs == 1) return 0;
      if(bs == 2) return 1;
   } 
   if (OrdType == "limit") 
   {
      if(bs == 1) return 2;
      if(bs == 2) return 3;
   } 
   if (OrdType == "stop") 
   {
      if(bs == 1) return 4;
      if(bs == 2) return 5;
   }
   return -1;  
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type, double price)
  {
   int r=0;
   color clr=Green;
   double s=0,t=0;   

   if(type==-1) return;

   if(type==1 || type==3 || type==5)
     {
      clr=Red;
      if(sl>0) s=NormalizeDouble(price+sl*Point,Digits);
      if(tp>0) t=NormalizeDouble(price-tp*Point,Digits);
     }

   if(type==0 || type==2 || type==4)
     {
      clr=Blue;
      if(sl>0) s=NormalizeDouble(price-sl*Point,Digits);
      if(tp>0) t=NormalizeDouble(price+tp*Point,Digits);
     }

   r=OrderSend(NULL,type,lot,NormalizeDouble(price,Digits),slippage,s,t,"",Magic,0,clr);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+    

Пытался написать вам в приват спросить детали, промежуточная версия(возможны ошибки).

//+------------------------------------------------------------------+
//|                                                      Candler.mq4 |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

input int slippage  = 20;
input int sl  = 100;
input int tp  = 100;
input double lot = 0.1;
input int Points = 30;
input int Delta  = 15;
input int Count  = 3;
input int HighCandle  = 1; // 1 - Close/Open, 2 High/Low длина свечи

extern int Magic = 999;
enum _TypeOrders{ 
   market,
   limit,
   stop
};
extern _TypeOrders TypeOrder = market;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Candles(int type)
  {
   int count=0;
   for(int i=1;i<=Count;i++)
     {     
        double dl = 0;
        
        if(HighCandle == 2) dl = High[i]-Low[i];
        else dl = MathAbs(Close[i]-Open[i]);
        
      if(Close[i]>Open[i] && type==1 && dl>=Points*Point && dl<=(Points+Delta)*Point)//bulls
        {
         count++;
        }

      if(Close[i]<Open[i] && type==2 && dl>=Points*Point && dl<=(Points+Delta)*Point)//bear
        {
         count++;
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
      if(Candles(1) == Count && CountOrders(0) < 1 && CountOrders(2) < 1 && CountOrders(4) < 1)
      {        
         PutOrder(OrderPlace(1), Ask);
      }
      if(Candles(2) == Count && CountOrders(1) < 1 && CountOrders(3) < 1 && CountOrders(5) < 1)
      {
         PutOrder(OrderPlace(2), Bid);
      }
  
   Comment("\n Bulls Candles: ",Candles(1),
           "\n Bears Candles: ",Candles(2));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountOrders(int type)
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OrderPlace(int bs) 
  {  
   string OrdType = EnumToString(TypeOrder);
   if (OrdType == "market") 
   {
      if(bs == 1) return 0;
      if(bs == 2) return 1;
   } 
   if (OrdType == "limit") 
   {
      if(bs == 1) return 2;
      if(bs == 2) return 3;
   } 
   if (OrdType == "stop") 
   {
      if(bs == 1) return 4;
      if(bs == 2) return 5;
   }
   return -1;  
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type, double price)
  {
   int r=0;
   color clr=Green;
   double s=0,t=0;

   if(type==-1) return;

   if(type==1 || type==3 || type==5)
     {
      clr=Red;
      if(sl>0) s=NormalizeDouble(price+sl*Point,Digits);
      if(tp>0) t=NormalizeDouble(price-tp*Point,Digits);
     }

   if(type==0 || type==2 || type==4)
     {
      clr=Blue;
      if(sl>0) s=NormalizeDouble(price-sl*Point,Digits);
      if(tp>0) t=NormalizeDouble(price+tp*Point,Digits);
     }

   r=OrderSend(NULL,type,lot,NormalizeDouble(price,Digits),slippage,s,t,"",Magic,0,clr);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+  

депо может не выдержать  

на самом деле для минутной хватит и месяца теста, но повыше качество  

очень смущает спред, дикие скачки в лоте и качество моделирования.
На истории много советников есть которые такой график рисуют.
Попробуйте на демо поставить.

читер, решил обойти систему?  

У меня почему то не совпадает график с вашим даже близко.
Какие индикаторы и настройки нужно указать, не совсем уверен что все индюки сработали.

перезалейте файл.

Тестируют конечно, но результаты почти всегда печальны.

скопировал твой код от советника по индикатору YzYz, изменив имя индикатора, но почему то пропускает стрелки часто, не закрывает по ним, может дело в индикаторе конечно…

Out of range array выбивает.

СХема конечная интересная, но то, что вы предлагете, только чуть отсрочит слив депо, т.к. погонял его против тренда, идет быстрый слив, за возможный мизерный профит.
По моему нужно немного изменить ход торговли на 3 колене, если ситуация идет не в нашу пользу.
Например открыть противоположный лот и закрыть в ноль с предыдущими и начать торговлю заново.

хорошо, попробую  

Выставлять надо стрелочки по факту на следующий бар, а не на текущий, как он рисует.
Т.е. можете прогнать на истории и все его стрелки на сигнал покупки/продажи сдвинуть на 1 бар вперед и увидите, как индюк ошибается. Смысл писать очередной сливатор?