Классы-обертки для индикаторов

[RegXRay]

В одной из статей из серии статей "УНИВЕРСАЛЬНЫЙ ТОРГОВЫЙ ЭКСПЕРТ" познакомился со объектно-ориентированным способом определения индикаторов. Более подробно можно узнать из ссылки ниже.
В этой теме предлагаю делиться своими классами для различных пользовательских индикаторов.
Например для индикатора SuperTrend supertrend.zip
Вот такой класс-обертка

//+------------------------------------------------------------------+
//|                                                 CSuperTrend.mqh  |
//+------------------------------------------------------------------+
enum Trend{Up,Dn,None};
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CSuperTrend
  {
private:
   int               m_supertrend_handle;       // Хендл индикатора
   ENUM_TIMEFRAMES   m_timeframe;               // Таймфрейм
   string            m_symbol;                  // Инструмент
   int               m_period;                  // Период
   double            m_multiplier;              // множитель
   void              Init(void);

public:
                     CSuperTrend(void);
/*Params*/
   //Set
   void              Timeframe(ENUM_TIMEFRAMES  timeframe);//
   void              Symbol(string symbol);
   void              Period(int period);
   void              Multiplier(double multiplier);
   //Get
   ENUM_TIMEFRAMES   Timeframe(void);
   string            Symbol(void);
   int               Period(void);
   double            Multiplier(void);

/*Out values*/
   double            Value(int index);
   Trend             Trend(int index);
  };
//+------------------------------------------------------------------+
//| Конструктор по умолчанию.                                        |
//+------------------------------------------------------------------+
CSuperTrend::CSuperTrend(void) :
m_symbol(_Symbol),
m_timeframe(PERIOD_CURRENT),
m_period(18),
m_multiplier(1.7)
  {
  }
//+------------------------------------------------------------------+
//| Инициализация.                                                   |
//+------------------------------------------------------------------+
CSuperTrend::Init(void)
  {
   if(m_supertrend_handle!=INVALID_HANDLE)
     {
      bool res=IndicatorRelease(m_supertrend_handle);
      if(!res)
        {
         string text="Realise SuperTrend indicator failed. Error ID: "+(string)GetLastError();
        }
     }
   m_supertrend_handle=iCustom(m_symbol,m_timeframe,"supertrend",m_period,m_multiplier);

   if(m_supertrend_handle==INVALID_HANDLE)
     {
      string params="(Period:"+(string)m_period+", Multipier:"+(string)m_multiplier+")";
      string text="Create SuperTrend indicator failed"+params+". Error ID: "+(string)GetLastError();
     }

  }
//+------------------------------------------------------------------+
//| Установка таймфрейма.                                            |
//+------------------------------------------------------------------+
void CSuperTrend::Timeframe(ENUM_TIMEFRAMES  tf)
  {
   m_timeframe=tf;
   if(m_supertrend_handle!=INVALID_HANDLE)
      Init();
  }
//+------------------------------------------------------------------+
//| Возвращает текущий таймфрейм.                                    |
//+------------------------------------------------------------------+
ENUM_TIMEFRAMES  CSuperTrend::Timeframe(void)
  {
   return m_timeframe;
  }
//+------------------------------------------------------------------+
//| Устанавливает символ, на котором должен быть рассчитан индикатор |
//+------------------------------------------------------------------+
void CSuperTrend::Symbol(string symbol)
  {
   m_symbol=symbol;
   if(m_supertrend_handle!=INVALID_HANDLE)
      Init();
  }
//+------------------------------------------------------------------+
//| Возвращает символ, для которого рассчитывается индикатор         |
//+------------------------------------------------------------------+
string CSuperTrend::Symbol(void)
  {
   return m_symbol;
  }
//+------------------------------------------------------------------+
//| Устанавливает период расчета индикатора|
//+------------------------------------------------------------------+
void CSuperTrend::Period(int period)
  {
   m_period=period;
   if(m_supertrend_handle!=INVALID_HANDLE)
      Init();
  }
//+------------------------------------------------------------------+
//| Возвращает период       |
//+------------------------------------------------------------------+
int CSuperTrend::Period(void)
  {
   return m_period;
  }
//+------------------------------------------------------------------+
//| Устанавливает множитель|
//+------------------------------------------------------------------+
void CSuperTrend::Multiplier(double multiplier)
  {
   m_multiplier=multiplier;
   if(m_supertrend_handle!=INVALID_HANDLE)
      Init();
  }
//+------------------------------------------------------------------+
//| Возвращает множитель       |
//+------------------------------------------------------------------+
double CSuperTrend::Multiplier(void)
  {
   return m_multiplier;
  }
//
// Значение 0-ого буфера  индикатора на баре index
//+------------------------------------------------------------------+
double            CSuperTrend::Value(int index)
  {
   if(m_supertrend_handle==INVALID_HANDLE)
      Init();
   double values[];
   if(CopyBuffer(m_supertrend_handle,0,index,1,values))
      return values[0];
   return EMPTY_VALUE;
  }
// Определяем тренд на баре index
//+------------------------------------------------------------------+
Trend            CSuperTrend::Trend(int index)
  {
   double val=Value(index);
   double close=iClose(m_symbol,m_timeframe,0);

   return (val>close)?Dn:((val<close)?Up:None);
  }
//+------------------------------------------------------------------+

 

[Yra]

RegXRay Здравствуйте
вы тут пишете что продолжите описание алгоритмов а ничего не пишете а меня заинтересовало, да меня интересуют любые открытые коды на языке MQL5 так как очень хочу и это изучить что=бы переписать все свои программы на это язык.

 

[Yra]

В одной из статей из серии статей "УНИВЕРСАЛЬНЫЙ ТОРГОВЫЙ ЭКСПЕРТ" познакомился со объектно-ориентированным способом определения индикаторов. Более подробно можно узнать из ссылки ниже.
В этой теме предлагаю делиться своими классами для различных пользовательских индикаторов.
Например для индикатора SuperTrend supertrend.zip
Вот такой класс-обертка
[/CODE]

Здравствуйте я очень сильно извиняюсь даже как-то не удобно спрашивать,что это такое "класс-обертка для индикатора" на языке QL5 ,на MQL четвертом я не встречал такое выражение потому что самоучка пожалуйста кто знает поясните мне пожалуйста.

 

[Алиса без страны]

Классы-обёртки для индикаторов в MetaTrader 5: Упрощение работы с индикаторами

Программирование в MetaTrader 5 (MT5) предоставляет трейдерам и разработчикам огромные возможности для создания алгоритмических стратегий. Одним из ключевых компонентов таких стратегий являются индикаторы. Однако работа с индикаторами через стандартные функции терминала часто оказывается громоздкой, особенно если нужно вызывать индикаторы многократно. Решением этой проблемы являются классы-обёртки для индикаторов.

В этой статье мы рассмотрим, как они упрощают работу с индикаторами, их основные преимущества и принципы реализации.


Что такое классы-обёртки для индикаторов?

Классы-обёртки для индикаторов — это программные конструкции, которые позволяют взаимодействовать с индикаторами через объектно-ориентированный подход. Вместо того чтобы многократно вызывать стандартные функции вроде iMA, iRSI и т.д., вы можете создать универсальный класс, который инкапсулирует всю работу с индикатором.

Пример без обёртки:


double value = iMA(NULL, 0, 14, 0, MODE_SMA, PRICE_CLOSE, 0);

Пример с использованием обёртки:

CIndicatorMA ma(14, MODE_SMA, PRICE_CLOSE);


double value = ma.GetValue(0);

Обёртка позволяет значительно сократить код и повысить читаемость программы.

Зачем использовать классы-обёртки?


1. Упрощение кода: Вместо многочисленных вызовов функций с длинными параметрами вы получаете компактный и понятный интерфейс.


2. Повышение читаемости: Код становится более структурированным, что особенно важно при разработке сложных алгоритмов.


3. Модульность: Логика работы с индикатором изолируется внутри класса, что упрощает тестирование и отладку.


4. Повторное использование: Один раз создав класс-обёртку, вы можете использовать его в любых проектах.

Как реализовать класс-обёртку для индикатора?


Рассмотрим пример реализации обёртки для скользящей средней (MA).

1. Объявление класса:

class CIndicatorMA {


private:


int handle; // Хэндл индикатора


int period; // Период MA


int maMethod; // Метод расчёта MA


int appliedPrice; // Применяемая цена





public:


// Конструктор


CIndicatorMA(int _period, int _maMethod, int _appliedPrice) {


period = _period;


maMethod = _maMethod;


appliedPrice = _appliedPrice;


handle = iMA(NULL, 0, period, 0, maMethod, appliedPrice);


}

// Метод получения значения


double GetValue(int shift) {


double value[];


if (CopyBuffer(handle, 0, shift, 1, value) > 0)


return value[0];


return 0.0;


}





// Деструктор


~CIndicatorMA() {


IndicatorRelease(handle);


}

2. Использование класса:


CIndicatorMA ma(14, MODE_SMA, PRICE_CLOSE);


double currentValue = ma.GetValue(0);

Обёртки для других индикаторов

Аналогично можно создать классы-обёртки для любых других индикаторов, например:


• RSI (Relative Strength Index):


class CIndicatorRSI {


// Аналогичная структура с использованием функции iRSI


};


• MACD (Moving Average Convergence Divergence):





class CIndicatorMACD {


// Обёртка для MACD с обработкой всех трёх линий (main, signal, histogram)


};

• Custom-индикаторы: Для работы с пользовательскими индикаторами используется функция iCustom.

Преимущества для разработчиков

Использование классов-обёрток особенно полезно при создании сложных торговых роботов, где требуется одновременная работа с несколькими индикаторами. Например:


1. Уменьшается вероятность ошибок при копировании данных из буфера.


2. Упрощается добавление новых индикаторов в код робота.


3. Стратегии становятся более гибкими благодаря возможности менять параметры через классы.


Пример практического использования


Допустим, вы разрабатываете стратегию, основанную на пересечении двух скользящих средних (быстрой и медленной). С классами-обёртками код будет выглядеть компактно и понятно:





CIndicatorMA fastMA(12, MODE_EMA, PRICE_CLOSE);


CIndicatorMA slowMA(26, MODE_EMA, PRICE_CLOSE);





if (fastMA.GetValue(0) > slowMA.GetValue(0) &&


fastMA.GetValue(1) <= slowMA.GetValue(1)) {


// Сигнал на покупку

Заключение

Классы-обёртки для индикаторов — это мощный инструмент для программистов, работающих с MetaTrader 5. Они позволяют упростить код, сделать его более структурированным и удобным для модификации. Если вы хотите создавать надёжные и гибкие алгоритмические стратегии, использование обёрток станет вашим незаменимым помощником.