overload operators new/new[] delete/delete[] globally C++

I have this sample code for overloading operator new and delete

#include <iostream>
#include <cstddef>
#include <new>

#ifdef USE_ZMALLOC
extern "C" {
#include "zmalloc.h"
}
#define m_malloc zmalloc
#define m_free zfree
#else
#ifdef USE_JEMALLOC
#include <jemalloc/jemalloc.h>
#define m_malloc je_malloc
#define m_free je_free
#else
#include "malloc.h"
#define m_malloc std::malloc
#define m_free std::free
#endif
#endif

// C++ requires that operator new return a legitimate pointer
//  even when zero bytes are requested. That's why if (size == 0) size = 1
void* operator new (std::size_t size) throw (std::bad_alloc) {
  using namespace std;
  if (size == 0) { // Handle 0-byte requests by treating them as 1-byte requests
    size = 1;
  }

  while (true) {
    void* mem = m_malloc(size);

    if (mem != nullptr) {
      return mem;
    } 

    new_handler global_handler = set_new_handler(nullptr);
    set_new_handler(global_handler);

    if (global_handler) {
      (*global_handler)();
    } else {
      throw bad_alloc();
    }

  }
}

void* operator new[] (std::size_t size) throw (std::bad_alloc) {
  return operator new(size);
}

void operator delete (void* ptr) throw() {
  if (ptr == nullptr) {
    return;
  }

  m_free(ptr);
}

void operator delete[] (void* ptr) throw() {
  operator delete(ptr);
}

This code is actually working and everything seems to be correct. My question is: when using valgrind, if I do something like this:

int main() {
  Foo** foo = new Foo*[10];

  std::cout << "# " << zmalloc_used_memory() << "." << std::endl;

  delete foo;  // Using wrong delete operator

  return 0;
}

valgrind doesn't complain about using the wrong operator delete. If I use the default operator new/delete pair, valgrind does warn me about the operator delete error.

1) Is there something wrong with my new/delete operators?
2) Is it normal that valgrind is not warning this kind of errors anymore?

Thx!