2018-05-09

new delete

new delete与malloc free的区别

对于基本数据类型 malloc与free new与delete 效果一致
new delete自动调用构造和析构
malloc不会调用构造函数 free 不会调用析构函数
基本数据类型 数组 delete delete[] 效果一样
复合数据类型 一定要配对使用

class mydata
{
public:
    void *p;
    mydata()
    {
        p = malloc(1024 * 1024 * 1024);
        cout << "DDDDDDDDDD" << endl;
    }
    ~mydata()
    {
        //free(p);
        cout << "delete" << endl;

    }
    
private:

};

//mydata my; //创建对象 自动调用构造函数


void test()
{
    mydata d1;  //栈上 创建时候调用构造函数  销毁时候调用析构函数
}

void mainxx5()
{
    int *p = new int(5);
    cout << (void*)p <<"P="<

new delete局部重载

//1 实现统计分配内存 释放内存的次数
//2 实现单例设计模式  实现避免反复delete出错

//new delete 内部 指针对当前类
int objs = 0;
void*g_p = nullptr;

class myclass
{
public:
    
    myclass()
    {
        objs++;
        cout << "creat" << endl;
    }
    ~myclass()
    {
        objs--;
        cout << "delete" << endl;
    }

    //operator 重载  针对new 重新作出解释  只针对当前类
    static void* operator new(size_t size) //单例模式 ： 只创建一个该类的对象
    {

        if (g_p == nullptr)     
        {
            cout << "new call" << endl;
            myclass *p = :: new myclass;  //:: 调用全局的new 
            g_p = p;
            return  p;   
        }
        else
        {
            return g_p;
        }
        
    }

    static void operator delete(void*p)  
    {

        if (g_p != nullptr)  //单例模式下 可避免连续delete造成的程序中断
        {
            cout << "delete call" << endl;
            ::delete p;
            g_p = nullptr;
        }

    }

    //static void* operator new(size_t size) //调用两次构造函数
    //{

    //  cout << "new call" << endl;
    //  myclass *p = :: new myclass;  //一次  调用全局的new
    //  g_p = p;
    //  return  p;    //调用new在一次
    //}

private:

};


void mainxx7()
{
    myclass *p = new myclass;   //
    myclass *p1 = new myclass;
    myclass *p2 = new myclass;
    int*xp = new int;
    delete p1;

    cout << objs << endl;

    cin.get();
}

new delete 全局重载

//new delete 三层： (调用顺序)
// 局部new --> ::new --> malloc --> 构造
// 析构 -->delete -->::delete --> free

//分配内存 优先 构造函数
//析构函数 优先 释放内存

//sizeof 统计类大小的原则 不统计代码区
//空类一个字节表示存在 等同与结构体

//全局内存管理 释放内存 分配内存

void * operator new(size_t size) //重载全局new
{
    cout << size << endl;
    cout << "g_new call" << endl;
    void *p = malloc(size);
    return p;
}

void * operator new[](size_t size) //重载全局new
{
    cout << "g_new [] call" << endl;
    return operator new(size); //每一个元素调用一次全局new
}



void  operator delete(void *p) //重载全局new
{
    cout << "g_delete call" << endl;
    free(p);
}

void  operator delete[](void *p) //重载全局new
{
    cout << "g_delete[] call" << endl;
    free(p);
}

class myClass1
{
public:
    myClass1()
    {
        cout << "creat call" << endl;
    }
    ~myClass1()
    {
        cout << "delete call" << endl;
    }

private:

};

//new delete 三层： (调用顺序)
// 局部new --> ::new --> malloc --> 构造
// 析构    -->delete -->::delete --> free

//分配内存 优先 构造函数
//析构函数 优先 释放内存

//sizeof 统计类大小的原则  不统计代码区
//空类一个字节表示存在 等同与结构体
void mainxx8()
{
    //int *p = new int(5);  //调用全局new
    //int*pint = new int[10]; //

    myClass1 *mp = new myClass1[10];
    delete[] mp;

    cin.get();
}

全局与局部new delete分析（调用顺序）

//new delete 本质函数 C++标准函数库 重写

//C++ C语言层
//C语言层管理内层 管理malloc free
//全局new 局部new 都会调用一次构造函数
//管理内层 避免既调用局部 又调用全局
//一般 局部类用于管理对象 全局管理基本数据类型 int double char
//
//两种情况 ：
// 1 局部new -> ::new -> malloc-> 构造 2局部new -> malloc -> 构造
// 1 析构 ->局部delete -> 全局 delete -> free

#include

void* mymalloc(size_t size)
{
    cout << "malloc all" << endl;
    return malloc(size);
}

void  myfree(void*p)
{
    cout << "free all" << endl;
    return free(p);
}

#define malloc  mymalloc 
#define free   myfree

void* operator new(size_t size)
{
    cout << "g_all  new" << endl;
    void *p = malloc(size); //调用全局new 
    return p;
}

void operator delete(void *p)
{
    cout << "g_all  delete" << endl;
    free(p);
}


class myclass2
{
public:
    myclass2()
    {
        cout << "creat call" << endl;
    }
    ~myclass2()
    {
        cout << "delete call" << endl;
    }

    void* operator new(size_t size)
    {
        cout << "myclass  new" << endl;
        myclass2 *p = ::new myclass2; //调用全局new 

        void *p = malloc(size);  //调用malloc 直接跳过::new

        return p;
    }

    void operator delete(void *p)
    {
        cout << "myclass  delete" << endl;
        ::delete p; //调用全局p
        free(p); //调用free  直接跳过::delete
    }

private:

};

//new delete 本质函数 C++标准函数库  重写


//C++  C语言层
//C语言层管理内层 管理malloc free
//全局new  局部new 都会调用一次构造函数
//管理内层 避免既调用局部 又调用全局
//一般 局部类用于管理对象 全局管理基本数据类型 int double char
//
//两种情况 ： 1 局部new -> ::new -> malloc-> 构造   2局部new -> malloc -> 构造
//            1 析构 ->局部delete -> 全局 delete -> free

void main()
{

    myclass2 *p = new myclass2;
    delete p;

    cin.get();
}