C++堆内存的分配及释放监控代码实现

堆内存的分配及释放监控

目前C++对堆内存的分配和释放，最担心的是：
1：分配和释放是否成对，如果发生内存泄漏，如果检测
2：频繁分配和释放，造成内存碎片，如何优化
本文就这两点，通过代码简单实现，供参考

全局内存监控

对全局内存监控简单方法就是重载全局new和free接口，通过重载接口，对分配/释放的次数，空间大小监控。

代码实现

//全局内存申请和释放次数统计及对比
#include <iostream>
#include <vector>
using namespace std;

int alloc_times = 0; 
int dealloc_times = 0; 
int allocated = 0; 

class MyClass{
	
private:
  double x,y,z;
};

void* operator new(size_t size)  { 
  void* p = std::malloc(size); 
  std::cout << "allocated " << size << " byte(s)\n"; 

  allocated+=size;
  alloc_times++;
  return p; 
} 
 
void operator delete(void* p) noexcept  { 
  std::cout << "deleted memory\n"; 

  dealloc_times++;
  return std::free(p); 
}

void* operator new[](size_t size)   {
  void* p = std::malloc(size); 
  allocated+=size;
  alloc_times++;

  std::cout << "allocated " << size << " byte(s) with new[]\n"; 
  return p; 
} 
void operator delete[](void* p) noexcept  { 
  std::cout << "deleted memory with delete[]\n"; 
   dealloc_times++;
  return std::free(p); 
}

int main()
{
  {
    MyClass* v=new MyClass[10];//24*10=240

    cout<<allocated<<endl;

    for(int i=0;i<10;i++)
    {
      MyClass* pc=new MyClass();//10
      delete pc;
    }
    
    delete[] v;
  }

  cout<<allocated<<endl;
  cout<<alloc_times<<endl;
  cout<<dealloc_times<<endl;
}

执行结果

kongcb@tcu-pc:~/testcode/memory$ g++ global_new.cpp -o test_global_new
kongcb@tcu-pc:~/testcode/memory$ ./test_global_new 
allocated 240 byte(s) with new[]
240
allocated 24 byte(s)
deleted memory
allocated 24 byte(s)
deleted memory
allocated 24 byte(s)
deleted memory
allocated 24 byte(s)
deleted memory
allocated 24 byte(s)
deleted memory
allocated 24 byte(s)
deleted memory
allocated 24 byte(s)
deleted memory
allocated 24 byte(s)
deleted memory
allocated 24 byte(s)
deleted memory
allocated 24 byte(s)
deleted memory
deleted memory with delete[]
480
11
11
kongcb@tcu-pc:~/testcode/memory$ 

简单分析

通过重载new和free，并将分配和释放的次数，分配字节数统计到全局变量中，实现了对堆空间的内存监控。
如发生new和free次数不一致，就需要关注了，是因为生命周期需要，还是有泄漏。

类内存监控

上例是对全局内存的监控，接下来对类内存的监控也做一个简单监控实现

代码实现

#include <iostream>
using namespace std;

class MyClass{
public:
  MyClass(const string& s):_s(s){
    cout<<"copy ctor"<<endl;
  }
  MyClass(){ cout<<"ctor"<<endl;}
  ~MyClass(){ cout<<"dtor"<<endl;}
  void process(){
    cout<<_s<<endl;
  }

  void* operator new(size_t size)   {
    cout<<"class new "<<endl;

   data++;
   //data+=size;
    return ::operator new(size);
  } 
  void operator delete(void* p)  {
    cout<<"class delete "<<endl;
    ::operator delete(p); 

    data--;
  } 

  static int data;
private:
  string _s;
};

int MyClass::data=0;
int main()
{
  MyClass* myObject = new MyClass{"Software"};  
  myObject->process();             
  delete myObject;

  cout<<"-----------"<<endl;
  MyClass* p = ::new MyClass{}; 
  ::delete p;
}

执行结果

kongcb@tcu-pc:~/testcode/memory$ g++ class_new.cpp -o test_class_new
kongcb@tcu-pc:~/testcode/memory$ ./test_class_new 
class new 
copy ctor
Software
dtor
class delete 
-----------
ctor
dtor

简单分析

以上代码中，如直接使用类内部void* operator new(size_t size)来申请空间，
调用new MyClass{"Software"};的时候，就会调用类的new来实现。
而如果直接调用全局的接口：::new MyClass{};就不会调用类的接口实现。
通过上述事例，监控类内部的new和free也可以通过重载实现。