gavindiaz/mql5
1
0
Fork 0
mirror of https://github.com/softwaredevelop/mql5.git synced 2026-11-02 11:16:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Leak-free pointer lifecycle, bounds protection & full VWMA routing

Browse Source
This commit is contained in:
Toh4iem9
2026-09-04 16:07:04 +02:00
parent 25a4422916
commit 99405cf61b
1 changed files with 276 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Include/MyIncludes/KeltnerChannel_Calculator.mqh
+276 -80
View File
@@ -1,10 +1,10 @@
//+------------------------------------------------------------------+
//| KeltnerChannel_Calculator.mqh|
//| VERSION 3.10: Dynamic Volume-Weighted MA Support (VWMA) |
//| Copyright 2026, xxxxxxxx |
//| Engine for Classic Keltner Channels (MA + ATR Envelope) |
//| Copyright 2026, xxxxxxxx|
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, xxxxxxxx"
#property version "3.10" // Refactored to support volume arrays for VWMA integration
#property version "4.00" // Leak-free pointer lifecycle, bounds protection & full VWMA routing
#ifndef KELTNER_CHANNEL_CALCULATOR_MQH
#define KELTNER_CHANNEL_CALCULATOR_MQH
@@ -18,41 +18,72 @@
class CKeltnerChannelCalculator
{
protected:
double m_multiplier;
double m_multiplier;
int m_ma_period;
int m_atr_period;
ENUM_MA_TYPE m_ma_type;
ENUM_ATR_SOURCE m_atr_source;
ENUM_APPLIED_PRICE_HA_ALL m_source_price;
//--- Composition: Use dedicated engines
//--- Composition Engines
CMovingAverageCalculator *m_ma_calc;
CATRCalculator *m_atr_calc;
//--- Internal Buffers for intermediate results
double m_atr_buffer[];
//--- Persistent State Buffers
double m_atr_buffer[];
virtual void CreateCalculators(void);
virtual void CreateCalculators(void);
public:
CKeltnerChannelCalculator(void);
virtual ~CKeltnerChannelCalculator(void);
virtual ~CKeltnerChannelCalculator(void);
//--- Init now takes ENUM_MA_TYPE
bool Init(int ma_p, ENUM_MA_TYPE ma_m, int atr_p, double mult, ENUM_ATR_SOURCE atr_src);
//--- Enhanced Pro Init (6 Parameters)
bool Init(const int ma_p, const ENUM_MA_TYPE ma_m, const int atr_p, const double mult,
const ENUM_ATR_SOURCE atr_src, const ENUM_APPLIED_PRICE_HA_ALL price_source);
//--- Standard Calculate (Without volume)
void Calculate(int rates_total, int prev_calculated, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type,
double &middle_buffer[], double &upper_buffer[], double &lower_buffer[]);
//--- Legacy Compatible Init (5 Parameters)
bool Init(const int ma_p, const ENUM_MA_TYPE ma_m, const int atr_p, const double mult, const ENUM_ATR_SOURCE atr_src)
{
return Init(ma_p, ma_m, atr_p, mult, atr_src, PRICE_TYPICAL_STD);
}
//--- Overloaded Calculate with Volume (Specifically for VWMA support)
void Calculate(int rates_total, int prev_calculated, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type,
const long &volume[],
double &middle_buffer[], double &upper_buffer[], double &lower_buffer[]);
//--- Standard Calculate (Without Volume)
void Calculate(const int rates_total, const int prev_calculated,
const double &open[], const double &high[], const double &low[], const double &close[],
const ENUM_APPLIED_PRICE price_type,
double &middle_buffer[], double &upper_buffer[], double &lower_buffer[]);
//--- Overloaded Calculate with Long Volume (For VWMA Support)
void Calculate(const int rates_total, const int prev_calculated,
const double &open[], const double &high[], const double &low[], const double &close[],
const ENUM_APPLIED_PRICE price_type,
const long &volume[],
double &middle_buffer[], double &upper_buffer[], double &lower_buffer[]);
//--- Overloaded Calculate with Double Volume (For MTF VWMA)
void Calculate(const int rates_total, const int prev_calculated,
const double &open[], const double &high[], const double &low[], const double &close[],
const ENUM_APPLIED_PRICE price_type,
const double &volume[],
double &middle_buffer[], double &upper_buffer[], double &lower_buffer[]);
int GetRequiredWarmup(void) const { return MathMax(m_ma_period, m_atr_period); }
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CKeltnerChannelCalculator::CKeltnerChannelCalculator(void)
CKeltnerChannelCalculator::CKeltnerChannelCalculator(void) : m_multiplier(2.0),
m_ma_period(20),
m_atr_period(10),
m_ma_type(EMA),
m_atr_source(ATR_SOURCE_STANDARD),
m_source_price(PRICE_TYPICAL_STD),
m_ma_calc(NULL),
m_atr_calc(NULL)
{
m_ma_calc = NULL;
m_atr_calc = NULL;
ArraySetAsSeries(m_atr_buffer, false);
}
//+------------------------------------------------------------------+
@@ -61,9 +92,15 @@ CKeltnerChannelCalculator::CKeltnerChannelCalculator(void)
CKeltnerChannelCalculator::~CKeltnerChannelCalculator(void)
{
if(CheckPointer(m_ma_calc) != POINTER_INVALID)
{
delete m_ma_calc;
m_ma_calc = NULL;
}
if(CheckPointer(m_atr_calc) != POINTER_INVALID)
{
delete m_atr_calc;
m_atr_calc = NULL;
}
}
//+------------------------------------------------------------------+
@@ -71,29 +108,45 @@ CKeltnerChannelCalculator::~CKeltnerChannelCalculator(void)
//+------------------------------------------------------------------+
void CKeltnerChannelCalculator::CreateCalculators(void)
{
if(CheckPointer(m_ma_calc) != POINTER_INVALID)
{
delete m_ma_calc;
m_ma_calc = NULL;
}
m_ma_calc = new CMovingAverageCalculator();
}
//+------------------------------------------------------------------+
//| Init |
//| Enhanced Pro Initialization |
//+------------------------------------------------------------------+
bool CKeltnerChannelCalculator::Init(int ma_p, ENUM_MA_TYPE ma_m, int atr_p, double mult, ENUM_ATR_SOURCE atr_src)
bool CKeltnerChannelCalculator::Init(const int ma_p, const ENUM_MA_TYPE ma_m, const int atr_p, const double mult,
const ENUM_ATR_SOURCE atr_src, const ENUM_APPLIED_PRICE_HA_ALL price_source)
{
m_multiplier = (mult <= 0) ? 2.0 : mult;
m_ma_period = (ma_p < 1) ? 1 : ma_p;
m_ma_type = ma_m;
m_atr_period = (atr_p < 1) ? 1 : atr_p;
m_multiplier = (mult <= 0.0) ? 2.0 : mult;
m_atr_source = atr_src;
m_source_price = price_source;
// Create MA Calculator (Virtual call handles HA override)
// 1. Initialize MA Calculator (Virtual Factory handles HA subclass)
CreateCalculators();
if(CheckPointer(m_ma_calc) == POINTER_INVALID || !m_ma_calc.Init(m_ma_period, m_ma_type))
return false;
// Create ATR Calculator based on source selection
if(atr_src == ATR_SOURCE_HEIKIN_ASHI)
// 2. Initialize ATR Calculator
if(CheckPointer(m_atr_calc) != POINTER_INVALID)
{
delete m_atr_calc;
m_atr_calc = NULL;
}
if(m_atr_source == ATR_SOURCE_HEIKIN_ASHI)
m_atr_calc = new CATRCalculator_HA();
else
m_atr_calc = new CATRCalculator();
if(CheckPointer(m_ma_calc) == POINTER_INVALID || !m_ma_calc.Init(ma_p, ma_m))
return false;
if(CheckPointer(m_atr_calc) == POINTER_INVALID || !m_atr_calc.Init(atr_p, ATR_POINTS))
if(CheckPointer(m_atr_calc) == POINTER_INVALID || !m_atr_calc.Init(m_atr_period, ATR_POINTS))
return false;
return true;
@@ -102,39 +155,72 @@ bool CKeltnerChannelCalculator::Init(int ma_p, ENUM_MA_TYPE ma_m, int atr_p, dou
//+------------------------------------------------------------------+
//| Calculate (Standard - No Volume) |
//+------------------------------------------------------------------+
void CKeltnerChannelCalculator::Calculate(int rates_total, int prev_calculated, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type,
void CKeltnerChannelCalculator::Calculate(const int rates_total, const int prev_calculated,
const double &open[], const double &high[], const double &low[], const double &close[],
const ENUM_APPLIED_PRICE price_type,
double &middle_buffer[], double &upper_buffer[], double &lower_buffer[])
{
if(CheckPointer(m_ma_calc) == POINTER_INVALID || CheckPointer(m_atr_calc) == POINTER_INVALID)
int warmup = GetRequiredWarmup();
if(rates_total <= warmup || CheckPointer(m_ma_calc) == POINTER_INVALID || CheckPointer(m_atr_calc) == POINTER_INVALID)
return;
//--- Resize internal ATR buffer
if(ArraySize(m_atr_buffer) != rates_total)
ArrayResize(m_atr_buffer, rates_total);
// Safe allocation of destination arrays
if(ArraySize(middle_buffer) != rates_total)
{
ArrayResize(middle_buffer, rates_total);
ArraySetAsSeries(middle_buffer, false);
ArrayInitialize(middle_buffer, EMPTY_VALUE);
}
if(ArraySize(upper_buffer) != rates_total)
{
ArrayResize(upper_buffer, rates_total);
ArraySetAsSeries(upper_buffer, false);
ArrayInitialize(upper_buffer, EMPTY_VALUE);
}
if(ArraySize(lower_buffer) != rates_total)
{
ArrayResize(lower_buffer, rates_total);
ArraySetAsSeries(lower_buffer, false);
ArrayInitialize(lower_buffer, EMPTY_VALUE);
}
//--- 1. Calculate Middle Line (MA) - Incremental
// Resize internal ATR buffer
if(ArraySize(m_atr_buffer) != rates_total)
{
ArrayResize(m_atr_buffer, rates_total);
ArraySetAsSeries(m_atr_buffer, false);
}
// 1. Calculate Middle Line (MA) - Incremental
m_ma_calc.Calculate(rates_total, prev_calculated, price_type, open, high, low, close, middle_buffer);
//--- 2. Calculate ATR - Incremental
// 2. Calculate ATR - Incremental
m_atr_calc.Calculate(rates_total, prev_calculated, open, high, low, close, m_atr_buffer);
//--- 3. Calculate Bands - Incremental Loop
int start_index = (prev_calculated > 0) ? prev_calculated - 1 : 0;
int ma_period = m_ma_calc.GetPeriod();
int atr_period = m_atr_calc.GetPeriod();
int start_pos = MathMax(ma_period, atr_period);
int loop_start = MathMax(start_pos, start_index);
for(int i = loop_start; i < rates_total; i++)
// 3. Clean invalid warmup range on fresh calculation
if(prev_calculated == 0)
{
// Ensure both components are valid
if(middle_buffer[i] != 0.0 && middle_buffer[i] != EMPTY_VALUE &&
m_atr_buffer[i] != 0.0 && m_atr_buffer[i] != EMPTY_VALUE)
for(int i = 0; i < warmup; i++)
{
upper_buffer[i] = middle_buffer[i] + (m_atr_buffer[i] * m_multiplier);
lower_buffer[i] = middle_buffer[i] - (m_atr_buffer[i] * m_multiplier);
middle_buffer[i] = EMPTY_VALUE;
upper_buffer[i] = EMPTY_VALUE;
lower_buffer[i] = EMPTY_VALUE;
}
}
int start_index = (prev_calculated > 0) ? (prev_calculated - 1) : warmup;
if(start_index < warmup)
start_index = warmup;
// 4. Calculate Bands
for(int i = start_index; i < rates_total; i++)
{
if(middle_buffer[i] != EMPTY_VALUE && middle_buffer[i] > 0.0 &&
m_atr_buffer[i] != EMPTY_VALUE && m_atr_buffer[i] > 0.0)
{
double channel_width = m_atr_buffer[i] * m_multiplier;
upper_buffer[i] = middle_buffer[i] + channel_width;
lower_buffer[i] = middle_buffer[i] - channel_width;
}
else
{
@@ -145,42 +231,148 @@ void CKeltnerChannelCalculator::Calculate(int rates_total, int prev_calculated,
}
//+------------------------------------------------------------------+
//| Calculate (Overloaded - With Volume for VWMA) |
//| Calculate (Overloaded - With Long Volume for VWMA) |
//+------------------------------------------------------------------+
void CKeltnerChannelCalculator::Calculate(int rates_total, int prev_calculated, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type,
void CKeltnerChannelCalculator::Calculate(const int rates_total, const int prev_calculated,
const double &open[], const double &high[], const double &low[], const double &close[],
const ENUM_APPLIED_PRICE price_type,
const long &volume[],
double &middle_buffer[], double &upper_buffer[], double &lower_buffer[])
{
if(CheckPointer(m_ma_calc) == POINTER_INVALID || CheckPointer(m_atr_calc) == POINTER_INVALID)
int warmup = GetRequiredWarmup();
if(rates_total <= warmup || CheckPointer(m_ma_calc) == POINTER_INVALID || CheckPointer(m_atr_calc) == POINTER_INVALID)
return;
//--- Resize internal ATR buffer
if(ArraySize(m_atr_buffer) != rates_total)
ArrayResize(m_atr_buffer, rates_total);
if(ArraySize(middle_buffer) != rates_total)
{
ArrayResize(middle_buffer, rates_total);
ArraySetAsSeries(middle_buffer, false);
ArrayInitialize(middle_buffer, EMPTY_VALUE);
}
if(ArraySize(upper_buffer) != rates_total)
{
ArrayResize(upper_buffer, rates_total);
ArraySetAsSeries(upper_buffer, false);
ArrayInitialize(upper_buffer, EMPTY_VALUE);
}
if(ArraySize(lower_buffer) != rates_total)
{
ArrayResize(lower_buffer, rates_total);
ArraySetAsSeries(lower_buffer, false);
ArrayInitialize(lower_buffer, EMPTY_VALUE);
}
//--- 1. Calculate Middle Line (MA) - Incremental with Volume
if(ArraySize(m_atr_buffer) != rates_total)
{
ArrayResize(m_atr_buffer, rates_total);
ArraySetAsSeries(m_atr_buffer, false);
}
// 1. Calculate Middle Line with Volume
m_ma_calc.Calculate(rates_total, prev_calculated, price_type, open, high, low, close, volume, middle_buffer);
//--- 2. Calculate ATR - Incremental
// 2. Calculate ATR
m_atr_calc.Calculate(rates_total, prev_calculated, open, high, low, close, m_atr_buffer);
//--- 3. Calculate Bands - Incremental Loop
int start_index = (prev_calculated > 0) ? prev_calculated - 1 : 0;
int ma_period = m_ma_calc.GetPeriod();
int atr_period = m_atr_calc.GetPeriod();
int start_pos = MathMax(ma_period, atr_period);
int loop_start = MathMax(start_pos, start_index);
for(int i = loop_start; i < rates_total; i++)
if(prev_calculated == 0)
{
// Ensure both components are valid
if(middle_buffer[i] != 0.0 && middle_buffer[i] != EMPTY_VALUE &&
m_atr_buffer[i] != 0.0 && m_atr_buffer[i] != EMPTY_VALUE)
for(int i = 0; i < warmup; i++)
{
upper_buffer[i] = middle_buffer[i] + (m_atr_buffer[i] * m_multiplier);
lower_buffer[i] = middle_buffer[i] - (m_atr_buffer[i] * m_multiplier);
middle_buffer[i] = EMPTY_VALUE;
upper_buffer[i] = EMPTY_VALUE;
lower_buffer[i] = EMPTY_VALUE;
}
}
int start_index = (prev_calculated > 0) ? (prev_calculated - 1) : warmup;
if(start_index < warmup)
start_index = warmup;
// 3. Calculate Bands
for(int i = start_index; i < rates_total; i++)
{
if(middle_buffer[i] != EMPTY_VALUE && middle_buffer[i] > 0.0 &&
m_atr_buffer[i] != EMPTY_VALUE && m_atr_buffer[i] > 0.0)
{
double channel_width = m_atr_buffer[i] * m_multiplier;
upper_buffer[i] = middle_buffer[i] + channel_width;
lower_buffer[i] = middle_buffer[i] - channel_width;
}
else
{
upper_buffer[i] = EMPTY_VALUE;
lower_buffer[i] = EMPTY_VALUE;
}
}
}
//+------------------------------------------------------------------+
//| Calculate (Overloaded - With Double Volume for MTF VWMA) |
//+------------------------------------------------------------------+
void CKeltnerChannelCalculator::Calculate(const int rates_total, const int prev_calculated,
const double &open[], const double &high[], const double &low[], const double &close[],
const ENUM_APPLIED_PRICE price_type,
const double &volume[],
double &middle_buffer[], double &upper_buffer[], double &lower_buffer[])
{
int warmup = GetRequiredWarmup();
if(rates_total <= warmup || CheckPointer(m_ma_calc) == POINTER_INVALID || CheckPointer(m_atr_calc) == POINTER_INVALID)
return;
if(ArraySize(middle_buffer) != rates_total)
{
ArrayResize(middle_buffer, rates_total);
ArraySetAsSeries(middle_buffer, false);
ArrayInitialize(middle_buffer, EMPTY_VALUE);
}
if(ArraySize(upper_buffer) != rates_total)
{
ArrayResize(upper_buffer, rates_total);
ArraySetAsSeries(upper_buffer, false);
ArrayInitialize(upper_buffer, EMPTY_VALUE);
}
if(ArraySize(lower_buffer) != rates_total)
{
ArrayResize(lower_buffer, rates_total);
ArraySetAsSeries(lower_buffer, false);
ArrayInitialize(lower_buffer, EMPTY_VALUE);
}
if(ArraySize(m_atr_buffer) != rates_total)
{
ArrayResize(m_atr_buffer, rates_total);
ArraySetAsSeries(m_atr_buffer, false);
}
// 1. Calculate Middle Line with Double Volume Array
m_ma_calc.Calculate(rates_total, prev_calculated, price_type, open, high, low, close, volume, middle_buffer);
// 2. Calculate ATR
m_atr_calc.Calculate(rates_total, prev_calculated, open, high, low, close, m_atr_buffer);
if(prev_calculated == 0)
{
for(int i = 0; i < warmup; i++)
{
middle_buffer[i] = EMPTY_VALUE;
upper_buffer[i] = EMPTY_VALUE;
lower_buffer[i] = EMPTY_VALUE;
}
}
int start_index = (prev_calculated > 0) ? (prev_calculated - 1) : warmup;
if(start_index < warmup)
start_index = warmup;
// 3. Calculate Bands
for(int i = start_index; i < rates_total; i++)
{
if(middle_buffer[i] != EMPTY_VALUE && middle_buffer[i] > 0.0 &&
m_atr_buffer[i] != EMPTY_VALUE && m_atr_buffer[i] > 0.0)
{
double channel_width = m_atr_buffer[i] * m_multiplier;
upper_buffer[i] = middle_buffer[i] + channel_width;
lower_buffer[i] = middle_buffer[i] - channel_width;
}
else
{
@@ -191,7 +383,7 @@ void CKeltnerChannelCalculator::Calculate(int rates_total, int prev_calculated,
}
//+==================================================================+
//| CLASS 2: CKeltnerChannelCalculator_HA |
//| CLASS 2: CKeltnerChannelCalculator_HA (Legacy) |
//+==================================================================+
class CKeltnerChannelCalculator_HA : public CKeltnerChannelCalculator
{
@@ -202,9 +394,13 @@ protected:
//+------------------------------------------------------------------+
void CKeltnerChannelCalculator_HA::CreateCalculators(void)
{
// Override to create HA version of MA calculator
if(CheckPointer(m_ma_calc) != POINTER_INVALID)
{
delete m_ma_calc;
m_ma_calc = NULL;
}
m_ma_calc = new CMovingAverageCalculator_HA();
}
//+------------------------------------------------------------------+
#endif // KELTNER_CHANNEL_CALCULATOR_MQH
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+