Operator delete question

I am running into this weird behavior with operator delete on an
embedded system, so I am wondering if this is standard C++ behavior or
is my compiler doing something wrong (RVCT 2.2 compiler). Appreciate
your patience as this is a long example:

static void * my_malloc (unsigned int numBytes)
{
  printf ("my malloc\n");
  return malloc(numBytes);
}

static void my_free (void *bufPtr)
{
  printf ("my free\n");
  free (bufPtr);
}

/* Interface I am trying to implement */
class ISocket
{
public:
  virtual void Release() = 0;
  virtual void TCPSockMethod() = 0;
};

/* The implementation design I have is thus:
 * All common methods are implemented in class Socket.
 * Function specific to TCP sockets are implemented in class
TCPSocket.
 * class Socket is still abstract, there are some methods
unimplemented there.
 */
class Socket : public ISocket
/* Dont ask about virtual inheritence :-(
 * Our embedded compiler does not support that. */
{
public:
  /* This does additional ref cnt management, removing for simplicity
*/
  virtual void Release () {printf ("Socket::Release\n"); delete this;}
  virtual void TCPSockMethod () = 0;

protected:
  Socket() {printf ("Socket: Ctor\n");}
  virtual ~Socket() {printf ("Socket: Dtor\n");}
};

/* TCPSocket is the concrete object. This one has overloaded new/
delete
 * operators to use my own memory management. */
class TCPSocket : public Socket
{
public:
  TCPSocket() {printf ("TCPSock: Ctor\n");}
  virtual ~TCPSocket() throw() {printf ("TCPSock: Dtor\n");}
  virtual void TCPSockMethod () {printf ("TCP Sock method\n");}
  static void* operator new (unsigned int num) {return my_malloc
(num);}
  static void operator delete (void *buf) {my_free(buf);}
};

int main()
{
  ISocket *pISock = static_cast <ISocket *> (new TCPSocket());
  pISock->Release();
  return 0;
}

Compiling with GCC and running this, I am getting the expected
results:
my malloc
Socket: Ctor
TCPSock: Ctor
Socket::Release
TCPSock: Dtor
Socket: Dtor
my free

However, compiling with my embedded compiler, I get different results:
after "Socket: Dtor", the global operator delete is getting called
(instead of the one I overloaded). I want to understand what does C++
standard say about this, or is this dependent on compilers?