C++ 重载运算符new/new[]delete/delete[]全局C++；

我有这个重载运算符new和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);
}

#包括
#包括
#包括
#ifdef使用zmaloc
外部“C”{
#包括“zmaloc.h”
}
#定义m_malloc zmalloc
#定义m_自由zfree
#否则
#ifdef使用_JEMALLOC
#包括
#定义m_malloc je_malloc
#定义m_free je_free
#否则
#包括“malloc.h”
#定义m_malloc std:：malloc
#定义m_free std:：free
#恩迪夫
#恩迪夫
//C++要求运算符新返回合法指针
//即使请求零字节。这就是为什么如果（size==0）size=1
void*运算符新建（std:：size\u t size）抛出（std:：bad\u alloc）{
使用名称空间std；
if（size==0）{//通过将0字节请求视为1字节请求来处理它们
尺寸=1；
}
while（true）{
void*mem=m_malloc（尺寸）；
if（mem！=nullptr）{
返回mem；
} 
new_handler global_handler=set_new_handler（nullptr）；
设置新的处理程序（全局处理程序）；
if（全局_处理程序）{
（*全球处理程序）（）；
}否则{
扔坏的东西；
}
}
}
void*运算符新[]（标准：：大小\u t大小）抛出（标准：：错误\u分配）{
返回运算符新（大小）；
}
void操作符delete（void*ptr）throw（）{
如果（ptr==nullptr）{
返回；
}
自由移动（ptr）；
}
void操作符delete[]（void*ptr）throw（）{
操作员删除（ptr）；
}

这段代码实际上正在运行，而且似乎一切都是正确的。 我的问题是：当使用valgrind时，如果我这样做：

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

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

  delete foo;  // Using wrong delete operator

  return 0;
}

intmain（）{
Foo**Foo=新Foo*[10]；
首先，这些不是重载（因为它们具有完全相同的原型）。这些是替换

最有可能的问题是Valgrind不知道您已替换了这些全局运算符。如果您在共享库中进行替换，Valgrind将看到函数和原型并能够将其挂接。但是，如果替换内容在可执行文件中，您需要告诉Valgrind。我认为这是可能的通过插装代码，这是非常困难的。更简单的方法是使用Valgrind选项--soname synonyms=somalloc=NONE。
我看不出操作符new[]如何调用数组元素的所有构造函数以及delete[]的元素析构函数.我遗漏了什么吗？在这个例子中，我只是创建了数组。我没有初始化数组中的元素array@RichardCritten这就是它的工作原理。您有一个“新表达式”，它会导致调用运算符new和构造函数。