c++ new delete知识总结

最新推荐文章于 2024-05-05 22:25:26 发布

cuit_618

最新推荐文章于 2024-05-05 22:25:26 发布

阅读量1.7k

点赞数 4

分类专栏： c++ 文章标签： c++new c++delete new-重载 delete-重载

本文链接：https://blog.csdn.net/zhaocuit/article/details/75023694

版权

c++ 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、C++的动态对象创建

当创建一个C++对象时，会发生两件事：
（1）为对象分配内存
（2）调用构造函数来初始化那个内存

然而，为对象分配内存可以用以下几种方式或在可选择的时间发生：
（1）在静态存储区域，存储空间在程序开始之前就可以分配。这个存储空间在整个运行期间都存在。
（2）无论何时到达一个特殊的执行点（左大括号）时，存储单元都可以在栈上被创建。出了执行点（右大括号），这个存储单元自动被释放。这些栈分配运算内置于处理器的指令集中，非常有效。但是，在写程序的时候，必须知道需要多少个存储单元，以便编译器知道生成正确的指令。
（3）存储单元也可以从一块称为堆的地方分配。这被称为动态内存分配。在运行时调用程序分配这些内存。这就意味着在任何时候可以分配内存以及分配多少内存，当然也需要负责决定何时释放内存。

二、C++的new 和 delete

C++中的解决方法是把创建一个对象所需的所有动作都结合在一个称为new的运算符里。我们当用new创建一个对象时，它就在堆里为对象分配内存并为这块内存调用构造函数。我们可以为类使用任何可用的构造函数，如果构造函数没有参数，可以写没有构造函数参数表的new表达式。

new表达式的反面是delete表达式。delete表达式首先调用析构函数，然后释放内存。如果正在删除的对象的指针是0，将不发生任何事情。为此，我们经常建议在删除指针后立即把指针赋值为0以免对它删除两次，从而产生某些问题。

#include <iostream>

using namespace std;

class B{
public:
     B(){
        cout<<"class b is created"<<endl;
    }
    ~B(){
        cout<<"class b is deleted"<<endl;
    }

};

int main(){

    B *a=new B;

    delete a;
    cout<<"-----------------"<<endl;

    B *b=new B[3];

    //空的方括号告诉编译器产生代码，该代码的任务是将从数组创建时存放在某处的对象数量取回，并为数组的所有对象调用析构函数。
    delete []b;
}

最终打印结果为：
class b is created
class b is deleted
-----------------
class b is created
class b is created
class b is created
class b is deleted
class b is deleted
class b is deleted

三、重载局部new delete

重载的new必须有一个size_t参数（不管是局部new还是全局new，不管是new 还是new[]）。这个参数由编译器产生并传递给我们，它是要分配内存的对象的长度。必须返回一个指向等于这个长度（或者大于这个长度）的对象的指针。我们首先需要明白的一点就是：operator new()的返回值是一个void*。它所做的是分配内存，而不是完成一个对象建立–直到构造函数调用了才完成对象的创建，它是编译器确保做的动作，不在我们的控制范围之内了，所以我们就没有必要考虑。

当在一个类内部重载new和delete的时候，我们称之为重载局部new delete。为一个类重载new和delete的时候，尽管不必显式的使用static，但是实际上仍是在创建static成员函数。它的语法也和重载任何其它运算符一样。当编译器看到使用new创建自己定义的类的对象时，它会选择相应版本的局部new delete函数去执行。

#include <iostream>

using namespace std;

class A{
public:
    static int count;

    A(){
    cout<<"class a is created"<<endl;
    }
    ~A(){
        cout<<"class a is deleted"<<endl;
    }

    //局部new重载
    /*注意：当执行A *a=new A时，会先调用这个局部new重载函数，然后调用了2次构造函数，但返回的对象的内存地址却是相同的一个，因此可以理解为只创建了一个对象，不知道为啥会调用2次构造函数。*/
    static void * operator new(size_t size){
        cout<<"jubu new is called"<<endl;
        count++;
        A *a=::new A;

        return a;
    }

    //局部delete重载
    static void operator delete(void *p){
        cout<<"jubu delete is called "<<p<<endl;
        count--;
        ::delete p;

    }

    //局部new[]重载
    static void * operator new[](size_t size){
        cout<<"jubu [] new is called"<<endl;

        return operator new(size);
    }

    //局部delete[]重载
    static void operator delete[](void *p){
        cout<<"jubu [] delete is called"<<endl;
        operator delete(p);
    }
};

int A::count=0;



int main(){
    A *a=new A;//调用局部重载new
    delete a;//调用局部重载delete
    cout<<"-----------------"<<endl;

    A *b=new A[3];//调用局部重载new[]
    delete []b;//调用局部重载delete[]
}
上述程序输出结果为：
jubu new is called
class a is created   
class a is created
class a is deleted
jubu delete is called 0x7111a0
-----------------
jubu [] new is called
jubu new is called
class a is created
class a is created
class a is created
class a is created
class a is deleted
class a is deleted
class a is deleted
jubu [] delete is called
jubu delete is called 0x7111a0

四、全局new delete重载

全局new delete重载，即相关的重载方法，写在和main方法同级的代码块中，针对整个系统有效，而上述局部new delete重载只是针对本类有效。

#include <iostream>

using namespace std;

class A{
public:
    static int count;

    A(){
        cout<<"class a is created"<<endl;
    }
    ~A(){
        cout<<"class a is deleted"<<endl;
    }

    //局部new重载
    static void * operator new(size_t size){
        cout<<"jubu new is called"<<endl;
        count++;
        A *a=::new A;

        return a;
    }

    //局部delete重载
    static void operator delete(void *p){
        cout<<"jubu delete is called "<<p<<endl;
        count--;
        ::delete p;

    }

    //局部new重载
    static void * operator new[](size_t size){
        cout<<"jubu [] new is called"<<endl;

        return operator new(size);
    }

    //局部delete重载
    static void operator delete[](void *p){
        cout<<"jubu [] delete is called"<<endl;
        operator delete(p);
    }
};

int A::count=0;

//全局new重载
void * operator new(size_t size){
    if(size==0){
        return 0;
    }
    void *p=malloc(size);
    cout<<"quanju new is called "<<p<<endl;
    return p;
}
//全局new[]重载
void * operator new[](size_t size){
    cout<<"quanju[] new is called "<<endl;
    return operator new(size);
}
//全局delete重载
void operator delete(void *p){
    cout<<"quanju delete is called "<<p<<endl;
    free(p);
}
//全局delete[]重载
void operator delete[](void *p){
    cout<<"quanju[] delete is called "<<p<<endl;
    operator delete(p);
}

int main(){
    int *x=new int(12);
    delete x;
    cout<<"----------"<<endl;

    int *p=new int[10];
    delete []p;
    cout<<"-----------------"<<endl;

    A *a=new A;
    delete a;
    cout<<"-----------------"<<endl;

    A *b=new A[3];
    delete []b;
}
上述程序执行结果为：
//int *x=new int(12);
//delete x;
quanju new is called 0x1e11a0
quanju delete is called 0x1e11a0
----------
//int *p=new int[10];
//delete []p;
quanju[] new is called
quanju new is called 0x1e11a0
quanju[] delete is called 0x1e11a0
quanju delete is called 0x1e11a0
-----------------
//A *a=new A;
//delete a;
jubu new is called
quanju new is called 0x1e11a0
class a is created
class a is created
class a is deleted
jubu delete is called 0x1e11a0
quanju delete is called 0x1e11a0
-----------------
//A *a=new A[3];
//delete []a;
jubu [] new is called
jubu new is called
quanju new is called 0x1e11a0
class a is created
class a is created
class a is created
class a is created
class a is deleted
class a is deleted
class a is deleted
jubu [] delete is called
jubu delete is called 0x1e11a0
quanju delete is called 0x1e11a0

五、总结

当局部、全局new delete都被重载后，其和构造方法、析构方法的调用是有顺序的，具体如下图所示：
这里写图片描述