new 篇

c++中，我们对new很熟徐了，生成一个动态对象就会调用new，但是，大家真的是知道它的底层运作方式么？
new操作是通过调用new操作符来分配一块内存，类似于malloc的作用，只用通过调用new placement的操作符在这块分配好的内存上调用类的构造函数，返回指向对象的指针。我们下来看看这段代码

#ifndef BASE_H
#define BASE_H
#include <iostream>
using namespace std;
class Base
{
      public:
        Base()
        {
            std::cout << "call the Base:Base" << std::endl;
        }
};
#endif

//这里模拟operator new 的功能
extern void* func (size_t size);

//base.cpp
#include "base.h"
#include <stdlib.h>
#include <stdio.h>
void* func(size_t size)
{
    if(!size)
    {
        return NULL;
    }
    return malloc(size);
}

int main()
{
    bool ret = false;
    do
    {
        //分配内存
        void *ptr = func(sizeof(Base));
        if(!ptr)
        {
          break;
        }
        //这里是调用了new placement，在ptr指向的内存上调用Base构造
        Base *base = new(ptr)(Base);
        if(!base)
        {
              break;
         }
        ret = true;
        delete base;
        base = NULL;
    }while(false);
    return ret ? 0 : 1;
}

通过上面的代码，我们可以了解到整个new 操作符的整个底层调用流程，我们可以重载operator new 函数，来达到自己分配内存的目的，也还有一些其他的妙用，比方说来追中内存的分配和回收情况，来查看系统是否发生内存泄露的情况，这些技巧，下次再补上！

现在，我们来通过重载operator new 和operator delete 来追中内存的泄露情况！先看代码

//func.h
#ifndef FUNC_H
#define FUNC_H

#define DEBUG

#ifdef DEBUG
void *operator new (size_t size,const char *file,size_t line);
void operator delete (void *ptr);
#define Debug_New new(__FILE__,__LINE__)
#else
#define Debug_New new
#endif

#endif

//func.cpp
#include "func.h"
#include <stdlib.h>
#include <stdio.h>

#ifdef DEBUG
//文件名长度
const int FILE_SIZE = 32;
typedef struct Node
{
      char file[FILE_SIZE];
      size_t line;
      size_t size;
      Node *next;
}Node;
//Node*的数组长度
const int NODE_lEN = 1024;
//保存每个内存分配信息
static Node* nodeArray[NODE_LEN];
//hash出p处于数组的下标
int hashIndex(void *p)
{
      unsigned long val = reinterpret_cast<unsigned long>(p);
      return val % NODE_lEN;
}
//向数组插入Node
bool insert(Node *pn,void *p)
{
    ret = false;
    do
    {
        if(!pn || !p)
        {
            break;
        }
        int hashVal = hashIndex(p);
        pn->next = nodeArray[hashVal];
        nodeArray[hashVal] = pn;
        pn->next = pre;
        ret = true;
    }while(false);
    printf("[分配内存](%s,文件名:%s,行数:%d,大小:%d)\n",(ret ? "成功" :"失败"),pn->file,pn->line,pn->size);
    return ret;
}

//向数组删除Node
Node* erase(void *p)
{
      Node *ret = NULL;
      do
      {
          int hashVal = hashIndex(p);
          Node *pre = nodeArray[hashVal];
          if((void*)pre== (p - sizeof(Node))
          {
                ret = pre;
                nodeArray[hashVal] = pre->next;
          }
          else
          {
              Node *node = pre->next;
              while(node)
              {
                    if(void*)node == (p - sizeof(Node))
                    {
                          ret = node;
                          pre->next = node->next;
                          break;
                    }
                    pre = node;
                    node = pre->next;
               }
          }
    }while(false);
    if(ret)
    {
        printf("[释放内存](%s,文件名:%s,行数:%d,大小:%d)\n",(true ? "成功" : "失败"),ret->file,ret->line,ret->size);
    }
    else
    {
          printf("[释放内存](失败)\n");
     }
    return ret;
}
          
//重载new
void* operator new (size_t size,const char *file,size_t line)
{
      void *ret = NULL;
      bool flg = false;
      do
      {
            if(!size)
            {
                break;
            }
            int total = sizeof(Node) + size;
            void *pv = std::malloc(total);
            Node *pn = (Node*)(pv);
            if(!pn)
            {
                  break;
            }
            strncpy(pn->file,file,sizeof(pn->file)-1);
            pn->line = line;
            pb->size = size;
            pn->next = NULL;
            ret = insert(pn,(char*)pv + sizeof(Node)) ? (char*)pv + sizeof(Node) : NULL;
        }while(false);
        return ret;
}

//重载delete
void operator delete (void* p)
{
      void *ret = (void*)erase(p);
      free(ret);
  }

//base.h
#ifndef BASE_H
#define BASE_H

class Base
{
};

#endif

//main.cpp
#include "base.h"
#include "func.h"
int main()
{
    Base *ptr = new Base();
    delete ptr;
    ptr = NULL;
    return 0;
}

我们重载了全局的operator new 和全局的operator delete 函数，通过Node的队列，我们来控制内存，通过日志，我们可以清楚的发现，哪些内存没有被释放。
我把它放git里面了，地址为：https://github.com/flyerSon/practice/tree/master/leak