could static array cause memory leak in this case?

Question

//CVMI.cpp

static char* std1[] = {"a","b","c"};
static char* std2[] = {"1","2","3"};

CVMI::CVMI(HWND p)
{
  //Does nothing.
}

//CVMI.h

const int   cMaxIPAddr = 100;
class CVMI : public VMIListener
{
 public:
CVMI(HWND p); 
    VMI vmi;
bool    bOpen;
    char                sVoceraIPAddr[cMaxIPAddr + 1];
long                iMessageID; 
};

Above are the code of a class I'm using in a thread and runs a for loop. If put the following three lines within that for loop, then I notice my memory would shoot through the roof.

m_pVMI = new CVMI(m_hNotifyWnd);
delete m_pVMI;
m_pVMI = NULL;

What am I doing wrong here? I though my delete would handle the memory allocation every time already. Or do I have to specifially free up all the resource in a destructor ~CVMI()? . This is my first attempt of troubleshooting a memory leak and being a C++ beginner doesn't make it easier.

Edit:

 class VMI_API VMIListener : public Listener
 {                                                                                      

 public:

// Message acknowledgement.  iAckCode is one of AC codes.
virtual void    HandleAck(long iMessageID, char* sLoginID, int iAckCode) = 0;   
virtual void    HandleResponse(long iMessageID, char* sLoginID, char* sResponse) = 0;
virtual void    HandleConnectionFailed(void) = 0;
  };

Answer 1

You need to check several places:

1. the caller that uses "CVMI".

   As you described, there is no memory leak because you had "delete"

   m_pVMI = new CVMI(m_hNotifyWnd);
   delete m_pVMI;
   m_pVMI = NULL;
   

2. The classes "CVMI"

   According to your code, you "new"ed and immediately "delete"ed and your constructor does nothing, then this is not the place has memory leak.

3. The only fishy place is constructor of "VMIListener" or the base class "Listener" (if that one has base class as well, check the base class as well...), maybe it allocate to a memory variable like: m_foo = new CFoo(); in the constructor; However, if you don't have destructor defined for "VMIListener" (or Listener or super class), then memory leak is guaranteed.

Answer 2

std1 and std2, your static arrays, are not causing your memory leak. They aren't even used in the code above, so it's not clear where your title even comes from. As for the virtual destructors mentioned in the OP comments, it entirely depends on what Listener's implementation is since neither VMIListener nor CVMI are dynamically allocating memory.