MT4 EA终止前释放指针数组遇超时崩溃，求解决方案

Hey there! Let’s tackle your MT4 EA crash issue head-on. The root problem here is that you’re dynamically allocating Signal objects with new but not properly cleaning them up before the EA terminates, leading to memory leaks that cause MT4 to time out and crash. Let’s break down what’s wrong with your current code and how to fix it.

What’s Wrong With Your Attempted Cleanup Code #

Your cleanup logic has a few critical issues that are keeping it from working:

• Invalid method definition: void SignalList::Signal { isn’t a valid function signature—you need a proper method name (like ClearSignals) and correct syntax.
• Broken traversal: You’re modifying the original m_signals list with m_signals=m_signals.Next() before accessing its elements, which skips the first item and corrupts the list’s structure.
• Uninitialized pointer: The Signal pointer is declared but never assigned to any list element, so CheckPointer(Signal) will always return invalid.
• Incorrect type handling: You’re trying to cast CObject* to Signal* without proper type checking, which can lead to undefined behavior.

Correct Approach to Clean Up Dynamic Objects #

In MQL4, when you create objects with new and add them to a CObjectList (which I assume m_signals is), you must explicitly delete each dynamic object before the EA shuts down. The safest place to do this is in the OnDeinit() function—MT4 calls this automatically when the EA is removed or the platform closes.

Step 1: Ensure Your Signal Class Inherits from CObject #

First, confirm your Signal class properly inherits from CObject (this is required for MQL4’s object list system):

class Signal : public CObject
{
public:
   datetime signal_time;
   int order_type;
   string symbol;

   // Constructor to initialize default values
   Signal() : signal_time(0), order_type(0), symbol("") {}
};

Step 2: Implement a Safe Cleanup Method #

Add a method to your SignalList class (or directly in your EA) to traverse and delete all dynamic Signal objects safely:

void ClearSignalList()
{
   // Start at the first element of the list
   CObject* obj = m_signals.First();
   
   while(obj != NULL)
   {
       // Store the next element first (deleting the current one might break the link)
       CObject* nextObj = obj.Next();
       
       // Verify this is a dynamic Signal object before deleting
       if(CheckPointer(obj) == POINTER_DYNAMIC && obj.IsInstanceOf(Signal::ClassId()))
       {
           Signal* s = (Signal*)obj;
           Print("Deleting dynamic Signal for symbol: ", s.symbol);
           delete s; // Free the allocated memory
       }
       
       // Remove the object from the list
       m_signals.Delete(obj);
       
       // Move to the next element
       obj = nextObj;
   }
}

Step 3: Trigger Cleanup in OnDeinit() #

Make sure to call your cleanup function in the OnDeinit() callback to guarantee it runs before the EA terminates:

void OnDeinit(const int reason)
{
   // Clean up all Signal objects to prevent memory leaks
   ClearSignalList();
   
   // Optional: Clear the list entirely after deleting objects
   m_signals.Clear();
}

Step 4: Verify Your Object Allocation Code #

Double-check that your object creation logic is setting up objects correctly for later cleanup:

// Your original allocation code (adjusted for clarity)
string parts[];
if(StringSplit(row, ' ', parts) > 0)
{
   int len = ArraySize(parts);
   if(len != 7) return;
   
   Signal* s = new Signal();
   s.signal_time = time;
   s.order_type = (parts[4] == "BUY") ? OP_BUYLIMIT : OP_SELLLIMIT;
   s.symbol = parts[0];
   
   // Add the object to the list (we'll handle deletion manually)
   m_signals.Add(s);
}

Key Tips to Avoid Future Memory Leaks #

• Always pair new with delete: For every object you create with new, ensure there’s a corresponding delete call before the EA exits.
• Traverse lists safely: Store the next element before deleting the current one—this prevents losing your place in the list.
• Use type checking: IsInstanceOf() ensures you only delete objects of the correct type, avoiding accidental deletion of non-dynamic or unrelated objects.
• Never skip OnDeinit(): This is the official, reliable place to clean up resources in MT4 EAs.

内容的提问来源于stack exchange，提问作者ville07