C / C++ / MFC

bool is_stack_memory(void * p)
{
  char check;
  MEMORY_BASIC_INFORMATION m1,m2;
 
  ::ZeroMemory(&m1,sizeof(m1));
  ::ZeroMemory(&m2,sizeof(m2));
  ::VirtualQuery(p,&m1,sizeof(m1));
  ::VirtualQuery(&check,&m2,sizeof(m2));
 
  return m1.BaseAddress==m2.BaseAddress;
}

if(is_stack_memory(x)){
  printf("x has not been dynamically allocated\n");
  return MDERROR; // or whatever
}
else{
  delete [] x;
}

if (pointer)
  delete [] pointer;
pointer = NULL;

1. If you broadcast your message in your OnTimer handler with SendMessages, then each SendMessage executes directly (rather than thru the message pump) and completely. So, no concurrency problems here.
2. If you do the broadcasting with PostMessages, all the messages get queued and are serially executed by the message pump. No problem either.

class CTargetClass : public CObject_derivative
{
public:
   CTargetClass (CHandlingClass* pHandler)
....
public:
   void ReturnInfo (CInfo* pInfo);
}

CTargetClass::CTargetClass (CHandlingClass* pHandler)
{
   pHandler->RegisterTarget(this);
}

class CHandlingClass : public CSomeBaseClass
{
....
public: 
   void RegisterTarget (CTargetClass* pTarget);
   afx_msg void OnTimer(UINT nIDEvent);
protected:
   int m_iMaxTargets;
   CTargetClass* m_pTargets; // this will point to an array of m_iMaxTargets 
}

void CHandlingClass::CRegisterTarget (CTargerClass* pTarget)
{
   // for simplicity it's assumed that the m_pTargets array is always big enough
   // It would be much better to use STL containers or even MFC containers.
   m_pTargets[m_iMaxTargets] = pTarget;
   m_iMaxTargets++;
}

void CHandlingClass::OnTimer (UINT nIDEvent)
{
   if (nIDEvent == ID_OF_YOUR_TIMER) {
      int i;
      CInfo info;
      for (i=0; i<m_iMaxTargets; i++) {
         m_pTargets[i].ReturnInfo(&info);
         DoWhateverYouNeedWithTheInfo(info);
      }
   }
}