精华内容
下载资源
问答
  • C++ new delete new[] delete[]重载实现

    这篇博文主要是分析了C++ new()和构造函数的执行,delete()与析构函数的调用方式,通过全局重载和局部重载看清楚调用的关系

    using namespace std;
    #include <iostream>
    #include <cstdlib>
    
    class Student{
    
    public:
    
    	Student(){
    		cout <<  "Constructer" << endl;
    	}
    
    	~Student(){
    		cout << "析构函数" << endl;
    	}
    
    	static void* operator new(size_t size){
    		cout << "own new function" << endl;
    		Student* stu = (Student*)::operator new(size);
    		return stu;
    
    	}
    
    	static void operator delete(void* p){
    		cout << "own delete function" << endl;
    		::delete p;
    	}
    
    	static void* operator new[](size_t size){
    		cout <<  "own new[] function" <<endl;
    		return ::operator new(size);
    	}
       
    };
    
    
    void* operator new(size_t size){
    	cout << "global new function" << endl;
    	void* p = malloc(size);
    	return p;
    }
    
    
    void operator delete(void * p){
    	cout << "global delete function"<< endl;
    	free(p);
    }
    
    void operator delete[](void* p){
    	cout << "global delete[] function" << endl;
    	free(p);
    }
    
    void main(){
    
    	Student* student = new Student();
    	delete student;
    
    	//Student* student2 = new Student[5];
    	//delete[] student2;
    
    	cin.get();
    }


    可以看出执行顺序为:内部重载的new-->全局重载的new()--->malloc()-->构造函数初始化-->内部的析构函数---》内部的delete()--》全局的delete()-->free()函数




    可以看出重载new[]和delete[]先执行malloc()分配所需要的内存然后每个元素会调用构造函数进行初始化


    展开全文
  • 不同意义的newdeleteoperator前置:原始的内存空间分配 operator后置:原始的内存空间分配+构造与析构operator new 和 operator delete operator new: 和malloc一样,唯一任务是分配原始内存 operator delete: ...

    不同意义的new和delete

    operator前置:原始的内存空间分配
    operator后置:原始的内存空间分配+构造与析构

    operator new 和 operator delete

    • operator new: 和malloc一样,唯一任务是分配原始内存
    • operator delete: 释放operator new分配的内存,防止资源泄露

      void* operator new(size_t size);//operator new通常声明
      void operator delete(void* memory);//operator delete通常声明
      
      void* memory =  operator new(sizeof(string));
      operator delete(memory); 

    new operator和delete operator

    • new operator: 包括调用operator new申请内存空间,调用构造函数constructor,返回指向该对象的指针

      void * memory= operator new(sizeof(string));//申请内存空间
      call string::string("memory management") on memory;//内存对象初始化
      
      string *ps = static_cast<string*>(memory);//返回指向新对象的指针
    • delete operator: 包括调用析构函数,释放申请的内存空间
    delete ps;

    相当于:

    ps->~string;
    operator delete(ps);

    参考:《more effective c++》操作符(operators)章节

    展开全文
  • 1.new delete总结 分配 释放 类别 可否重载 malloc() free() C函数 不可 new delete C++表达式 不可 ::operator new() ::operator delete() C++函数 可 allocator<...

    1.new delete总结

    分配 释放 类别 可否重载
    malloc() free() C函数 不可
    new delete C++表达式 不可
    ::operator new() ::operator delete() C++函数
    allocator<T>::allocate() allocator<T>::deallocate() C++ 标准库 可自由设计并搭配任何容器

    new就是new operator,new[]就是 array new,new()就是placement new,::operator new()就是operator new函数,这是一个函数,下面一一详细介绍一下。

    2.new expression(new operator)

    Complex*pc = new Complex(1,2);

    上述的new我们称为new表达式,也就是关键字new,有的书上称为new operator,Complex是自己定义的一个类一个复数罢了,new的动作为先申请一块内存,然后调用构造函数。源代码抽象如下:

    Complex *pc;
    try{
        void* mem = operator new(sizeof(Complex));//allocate
        pc = static_cast<Complex*>(mem);//cast 指针类型的转型
        pc->Complex::Complex(1,2);//construct 注意只有编译器可以这样调用ctor(构造函数)
    }
    catch(std::bad_alloc){
        //若allocation失败就不执行constructor
    }

    可以看到我们外部并不能直接通过指针去直接调用构造函数,但可以通过placement new来调用构造函数,形式为new(p)Complex(1,2),p为一个Comlex指针。

    3.operator new函数

    void *operator new(size_t size, const std::nothrow_t&)
                        _THROW0()
    {
    void *p;
    while((p==malloc(size))==0){
            _TRY_BEGIN
                if(_callnewh(size)==0) break;
            _CATCH(std::bad_alloc) return(0);
            _CATCH_END
        }
    return (p);
    }

    以上代码是operator new 函数的源代码,该函数时可以被重载的,该函数输入一个size,malloc申请一个size的空间并返回,如果申请失败,会调用你可以自己定义的一个_callnewh(size)的一个函数,可以自己编辑怎么样删除多余的其他内存的函数,然后好分配给你正在需要申请的内存。std::nothrow_t表示这个函数不会抛出异常

    4.delete expression

    delete做的事情,先调用析构函数,然后把内存释放掉,调用接口如下:

    Complex* pc = new Complex(1,2);
    ...
    delete pc;
    
    

    编译器编译后如下:

    pc->~Complex();//先析构
    operator delete(pc); //然后释放内存

    前面说我们不能直接通过指针来调用构造函数,但是可以直接调用析构函数,operator delete的源码如下,可看出是调用的free函数。

    void __cdecl operator delete(void *p) _THROW0(){
        free(p);
    }

    5.array new(new[]), array delete(delete[])

    很容易理解array new就是一次申请多个对象,并调用多次构造函数,而之前的new只调用了一次构造函数,array delete就是先进行多次析构函数,之前的delete只调用了一次析构函数,在delete[]进行多次析构函数时,有的是倒着析构的,即最后一个对象开始析构,有的是正着析构的。如果该调用delete[]的地方调用了delete,一般对于有指针的对象是有影响的,一般对于没有指针的类是没有影响的。

    下面进行一个测试对比来看看这个过程。

    #include<iostream>
    using namespace std;
    class A {
    public:
    	int id;
    	A() :id(0) { cout << "default ctor. this=" << this << " id=" << id << endl; }
    	A(int i) :id(i) { cout << "ctor.this=" << this << " id=" << id << endl; }
    	~A() { cout << "dtor.this=" << this << " id=" << id << endl; }
    };
    int main() {
    	int size = 3;
    	A* buf = new A[size]; //必须要有默认构造函数
    	A* tmp = buf;
    	cout << "buf=" << buf << " tmp=" << tmp << endl;
    
    	for (int i = 0; i < size; i++)
    		new(tmp++)A(i);  //placement new,通过指针直接调用构造函数
    	cout << "buf=" << buf << " tmp=" << tmp << endl;
    	delete[] buf;
    	while (1);
    }
    

    输出结果如下:

    在上述代码中,调用delete[]和调用delete的效果是一样的,因为析构函数的作用其实不大,不会发生内存泄漏,下面是使用delete的实验结果,你用VS跑可能会报异常,不用管,如果你用内置类型就不会出现这样的问题了。

    下面我们进行一个新的测试那就是在类的里面定义指针,看delete[]和delete的结果有何区别:

    class A {
    public:
    	string* id;
        int capacity;
    	A(int cap = 5)  { 
            capacity = cap;
    		id = new string[capacity];
    	}
    	~A() { 
    		delete id;
    	}
    };
    
    int main(){
        A* p = new A[3];
        delete[] A;
    }
    

    这里使用的是delete会导致报错,因为string不是内置类型,在delete的时候析构函数是有意义的,而只有delete id的话,也就只调用了一次析构函数,因此是错误的。在调用delete的时候如果要释放数组,不是内置类型的需要使用delete[],内置类型用delete和delete[]都可以,因为在malloc的时候记录了总共要删除多大的内存,自定义类有指针就不能直接使用delete释放数组,没有指针一般用delete或者delete[]都可以。因为如果有指针申请了一块新的内存那么析构函数就很重要,申请多少个对象就要执行多少次析构函数。对比如下:

    int* p = new int[10];
    delete p;//和delete[] p相同的
    
    string* p = new string[10];
    delete[] p;//不可以使用delete p因为string 不是内置类型,构造函数有意义,必须执行构造函数

    那么会有同学问我自己写了一个类,里面成员都是内置类型那么我可以delete和delete[]随便用吗,答案是可以的,一般只要成员没有指针都没有关系。

    6.placement new

    placement new允许我们将对象构造于已经分配好的内存中,没有placement delete,因为placement new 根本没有分配内存。placement new的使用方式如下,可看到是先分配了一块内存,然后调用指针在已经分配的内存上构造了一个Complex对象。

    #include<new>
    char *buf = new char[sizeof(Complex)*3];
    Complex *pc = new(buf)Complex(1,2);
    ....
    delete[] buf;

    下面我们看抽象后的placement new源码:

    Complex *pc;
    try{
        void* mem = operator new(sizeof(Complex),buf);
        pc = static_cast<Complex*>(mem);
        pc->Complex::Complex(1,2);
    }
    catch(std::bad_alloc){
    }

    该operator new 函数的源码如下:

    void* operator new(size_t, void* loc){
        return loc;//因为不需要分配内存,因此只需要把这个定点的指针返回即可
    }

    7.参考资料

    C++内存管理机制-从平地到万丈高楼(完结)

    展开全文
  • c++ new delete new[] delete[] 底层实现

    千次阅读 2017-01-17 18:01:16
    关于deletedelete[]的相关实现。

    看了一些文章后觉得对下面几个概念没有一个清晰的讲解,我总结一下:
    对于内置类型:
    new []不会在首地址前4个字节定义数组长度。
    delete 和 delete[]是一样的执行效果,都会删除整个数组,要删除的长度从new时即可知道。
    对于自定义类型:
    new []会在首地址前4个字节定义数组长度。
    当delete[]时,会根据前4个字节所定义的长度来执行析构函数删除整个数组。
    如果只是delete数组首地址,只会删除第一个对象的值。
    ==============我是分割线================
    剩下的相关基础概念可以参考这篇文章:
    原文地址:
    http://blog.csdn.net/hazir/article/details/21413833
    原文内容:
    在 C++ 中,你也许经常使用 new 和 delete 来动态申请和释放内存,但你可曾想过以下问题呢?

    new 和 delete 是函数吗?
    new [] 和 delete [] 又是什么?什么时候用它们?
    你知道 operator new 和 operator delete 吗?
    为什么 new [] 出来的数组有时可以用 delete 释放有时又不行?

    如果你对这些问题都有疑问的话,不妨看看我这篇文章。

    new 和 delete 到底是什么?

    如果找工作的同学看一些面试的书,我相信都会遇到这样的题:sizeof 不是函数,然后举出一堆的理由来证明 sizeof 不是函数。在这里,和 sizeof 类似,new 和 delete 也不是函数,它们都是 C++ 定义的关键字,通过特定的语法可以组成表达式。和 sizeof 不同的是,sizeof 在编译时候就可以确定其返回值,new 和 delete 背后的机制则比较复杂。
    继续往下之前,请你想想你认为 new 应该要做些什么?也许你第一反应是,new 不就和 C 语言中的 malloc 函数一样嘛,就用来动态申请空间的。你答对了一半,看看下面语句:

    string *ps = new string(“hello world”);
    你就可以看出 new 和 malloc 还是有点不同的,malloc 申请完空间之后不会对内存进行必要的初始化,而 new 可以。所以 new expression 背后要做的事情不是你想象的那么简单。在我用实例来解释 new 背后的机制之前,你需要知道 operator new 和 operator delete 是什么玩意。

    operator new 和 operator delete

    这两个其实是 C++ 语言标准库的库函数,原型分别如下:

    void *operator new(size_t); //allocate an object
    void operator delete(void ); //free an object

    void *operator new; //allocate an array
    void operator delete[](void ); //free an array
    后面两个你可以先不看,后面再介绍。前面两个均是 C++ 标准库函数,你可能会觉得这是函数吗?请不要怀疑,这就是函数!C++ Primer 一书上说这不是重载 new 和 delete 表达式(如 operator= 就是重载 = 操作符),因为 new 和 delete 是不允许重载的。但我还没搞清楚为什么要用 operator new 和 operator delete 来命名,比较费解。我们只要知道它们的意思就可以了,这两个函数和 C 语言中的 malloc 和 free 函数有点像了,都是用来申请和释放内存的,并且 operator new 申请内存之后不对内存进行初始化,直接返回申请内存的指针。

    我们可以直接在我们的程序中使用这几个函数。

    new 和 delete 背后机制

    知道上面两个函数之后,我们用一个实例来解释 new 和 delete 背后的机制:

    我们不用简单的 C++ 内置类型来举例,使用复杂一点的类类型,定义一个类 A:

    class A
    {
    public:
    A(int v) : var(v)
    {
    fopen_s(&file, “test”, “r”);
    }
    ~A()
    {
    fclose(file);
    }

    private:
    int var;
    FILE *file;
    };
    很简单,类 A 中有两个私有成员,有一个构造函数和一个析构函数,构造函数中初始化私有变量 var 以及打开一个文件,析构函数关闭打开的文件。

    我们使用

    class *pA = new A(10);
    来创建一个类的对象,返回其指针 pA。如下图所示 new 背后完成的工作:

    简单总结一下:

    首先需要调用上面提到的 operator new 标准库函数,传入的参数为 class A 的大小,这里为 8 个字节,至于为什么是 8 个字节,你可以看看《深入 C++ 对象模型》一书,这里不做多解释。这样函数返回的是分配内存的起始地址,这里假设是 0x007da290。
    上面分配的内存是未初始化的,也是未类型化的,第二步就在这一块原始的内存上对类对象进行初始化,调用的是相应的构造函数,这里是调用 A:A(10); 这个函数,从图中也可以看到对这块申请的内存进行了初始化,var=10, file 指向打开的文件。
    最后一步就是返回新分配并构造好的对象的指针,这里 pA 就指向 0x007da290 这块内存,pA 的类型为类 A 对象的指针。
    所有这三步,你都可以通过反汇编找到相应的汇编代码,在这里我就不列出了。

    好了,那么 delete 都干了什么呢?还是接着上面的例子,如果这时想释放掉申请的类的对象怎么办?当然我们可以使用下面的语句来完成:

    delete pA;
    delete 所做的事情如下图所示:

    delete 就做了两件事情:

    调用 pA 指向对象的析构函数,对打开的文件进行关闭。
    通过上面提到的标准库函数 operator delete 来释放该对象的内存,传入函数的参数为 pA 的值,也就是 0x007d290。
    好了,解释完了 new 和 delete 背后所做的事情了,是不是觉得也很简单?不就多了一个构造函数和析构函数的调用嘛。

    如何申请和释放一个数组?

    我们经常要用到动态分配一个数组,也许是这样的:

    string *psa = new string[10]; //array of 10 empty strings
    int *pia = new int[10]; //array of 10 uninitialized ints
    上面在申请一个数组时都用到了 new [] 这个表达式来完成,按照我们上面讲到的 new 和 delete 知识,第一个数组是 string 类型,分配了保存对象的内存空间之后,将调用 string 类型的默认构造函数依次初始化数组中每个元素;第二个是申请具有内置类型的数组,分配了存储 10 个 int 对象的内存空间,但并没有初始化。

    如果我们想释放空间了,可以用下面两条语句:

    delete [] psa;
    delete [] pia;
    都用到 delete [] 表达式,注意这地方的 [] 一般情况下不能漏掉!我们也可以想象这两个语句分别干了什么:第一个对 10 个 string 对象分别调用析构函数,然后再释放掉为对象分配的所有内存空间;第二个因为是内置类型不存在析构函数,直接释放为 10 个 int 型分配的所有内存空间。

    这里对于第一种情况就有一个问题了:我们如何知道 psa 指向对象的数组的大小?怎么知道调用几次析构函数?

    这个问题直接导致我们需要在 new [] 一个对象数组时,需要保存数组的维度,C++ 的做法是在分配数组空间时多分配了 4 个字节的大小,专门保存数组的大小,在 delete [] 时就可以取出这个保存的数,就知道了需要调用析构函数多少次了。

    还是用图来说明比较清楚,我们定义了一个类 A,但不具体描述类的内容,这个类中有显示的构造函数、析构函数等。那么 当我们调用

    class A *pAa = new A[3];
    时需要做的事情如下:

    从这个图中我们可以看到申请时在数组对象的上面还多分配了 4 个字节用来保存数组的大小,但是最终返回的是对象数组的指针,而不是所有分配空间的起始地址。

    这样的话,释放就很简单了:

    delete [] pAa;

    这里要注意的两点是:

    调用析构函数的次数是从数组对象指针前面的 4 个字节中取出;
    传入 operator delete[] 函数的参数不是数组对象的指针 pAa,而是 pAa 的值减 4。
    为什么 new/delete 、new []/delete[] 要配对使用?

    其实说了这么多,还没到我写这篇文章的最原始意图。从上面解释的你应该懂了 new/delete、new[]/delete[] 的工作原理了,因为它们之间有差别,所以需要配对使用。但偏偏问题不是这么简单,这也是我遇到的问题,如下这段代码:

    int *pia = new int[10];
    delete []pia;
    这肯定是没问题的,但如果把 delete []pia; 换成 delete pia; 的话,会出问题吗?

    这就涉及到上面一节没提到的问题了。上面我提到了在 new [] 时多分配 4 个字节的缘由,因为析构时需要知道数组的大小,但如果不调用析构函数呢(如内置类型,这里的 int 数组)?我们在 new [] 时就没必要多分配那 4 个字节, delete [] 时直接到第二步释放为 int 数组分配的空间。如果这里使用 delete pia;那么将会调用 operator delete 函数,传入的参数是分配给数组的起始地址,所做的事情就是释放掉这块内存空间。不存在问题的。

    这里说的使用 new [] 用 delete 来释放对象的提前是:对象的类型是内置类型或者是无自定义的析构函数的类类型!

    我们看看如果是带有自定义析构函数的类类型,用 new [] 来创建类对象数组,而用 delete 来释放会发生什么?用上面的例子来说明:

    class A *pAa = new class A[3];
    delete pAa;
    那么 delete pAa; 做了两件事:

    调用一次 pAa 指向的对象的析构函数;
    调用 operator delete(pAa); 释放内存。
    显然,这里只对数组的第一个类对象调用了析构函数,后面的两个对象均没调用析构函数,如果类对象中申请了大量的内存需要在析构函数中释放,而你却在销毁数组对象时少调用了析构函数,这会造成内存泄漏。

    上面的问题你如果说没关系的话,那么第二点就是致命的了!直接释放 pAa 指向的内存空间,这个总是会造成严重的段错误,程序必然会奔溃!因为分配的空间的起始地址是 pAa 指向的地方减去 4 个字节的地方。你应该传入参数设为那个地址!

    同理,你可以分析如果使用 new 来分配,用 delete [] 来释放会出现什么问题?是不是总会导致程序错误?

    总的来说,记住一点即可:new/delete、new[]/delete[] 要配套使用总是没错的!

    展开全文
  • 原文:... C++中的new/delete与operator new/operator delete new operator/delete operator就是newdelete操作符,而operator new/operator delete是函数。
  • new delete

    2016-12-21 22:06:26
    堆操作 在c语言中我们对堆进行操作主要通过... 但newdelete并不等价于malloc和free,malloc和free是函数,而newdelete是运算符 newdelete的使用相比较malloc 和free 而言newdelete的用法要简单得多。#inclu
  • NewDelete的区别

    2019-07-21 09:21:16
    New和malloc的区别? C中动态开辟内存: malloc函数开辟 free函数释放...C++中动态开辟内存:New关键释放字开辟 Delete New 关键字 Int *p=new int; Delete 关键字 Delete p; 1、New是关键字 malloc是函数 2、...
  • 1.new/delete operator 2.operator new/delete 3.placement new
  • C++ 的 newdeletenew operator, operator new, placement new, delete operator, operator delete 1. new operator new operator 完成了两件事情:用于申请内存和初始化对象。 例如: string* ps = new ...
  • 在vs2015里,有这么一个文件 vcruntime_new.h 内容大致如下: #define __CRTDECL __cdecl  namespace std  {  struct nothrow_t { };  extern nothrow_t const nothrow;  }    _Ret_not...
  • new malloc delete free
  • 浅谈 C++ 中的 new/delete

    千次阅读 2016-03-17 21:31:37
    new 和 deletenew 和 delete 到底是什么?如果找工作的同学看一些面试的书,我相信都会遇到这样的题: sizeof不是函数,然后举出一堆的理由来证明 sizeof 不是函数。在这里,和sizeof类似,new和delete也不是函数,...
  • 浅谈 C++ 中的 new/deletenew[]/delete[]

    万次阅读 多人点赞 2014-03-17 22:49:32
    在 C++ 中,你也许经常使用 newdelete 来动态申请和释放内存,但你可曾想过以下问题呢? newdelete 是函数吗?new [] 和 delete [] 又是什么?什么时候用它们?你知道 operator new 和 operator delete 吗...
  • 【C++】 new deletenew[] delete[] 详解

    千次阅读 2019-09-03 16:29:50
      C++ 中,newdelete 和 sizeof 一样,都不是函数,都是操作符。面试经常回问 malloc/free 和 new/delete的区别和联系: malloc/free 只是动态分配内存空间/释放空间,new/delete 除了分配空间还会调用构造函数...
  • C++ newdelete

    千次阅读 多人点赞 2020-05-07 20:23:14
    在C语言中,动态分配内存用 malloc() 函数,释放内存用 free() 函数。...在cpp中,这两个函数仍然可以使用,但是C++又新增了两个关键字,newdeletenew 用来动态分配内存,delete 用来释放内...
  • 关于C++中new/deletenew[]/delete[]

    千次阅读 2018-10-08 14:20:43
    浅谈 C++ 中的 new/deletenew[]/delete[] operator new 和 operator delete 这两个其实是 C++ 语言标准库的库函数,原型分别如下: void *operator new(size_t); //allocate an object void *operator delete...
  • 重载operator new/delete/new[]/delete[]

    千次阅读 2018-10-06 12:25:45
    Abstact 之前看侯捷老师的C++面向对象开发上。老师讲了一个知识点,如下图: 在他的C++面向对象高级编程(下)课程中,侯捷老师讲了重载operator new,operator delete。...重载了operator new/delete/new[]/delet...
  • newdelete是C++的关键字,不是函数。而且,malloc 申请完空间之后不会对内存进行必要的初始化,而 new 可以。这两个其实是 C++ 语言标准库的库函数,原型分别如下:void *operator new(size_t); //allocate an ...
  • 二维指针的newdelete

    千次阅读 2017-01-14 17:29:17
    二维指针的newdelete New: A** ga = new A*[m]; for(int i = 0; i  {  ga[i] = new A[n]; } Delete: for(int i = 0; i  {  delete []ga[i]; } delete []ga; 应此 C/...
  • new delete 解析

    千次阅读 2017-05-13 12:07:45
    newdelete是什么 程序运行时,计算机的内存被分为4个区域:程序代码区,全程数据区,栈和堆。其中堆上的内存可以被用户自由分配和释放。C语言中提供了malloc(还有calloc和realloc)和free函数来进行动态内存管理。...
  • C++的new/delete当我们使用一条new表达式时:// new表达式 string *sp = new string("a value"); string *arr = new string[10];实际执行了三步操作,第一步:new表达式调用一个名为operator new(或者operator new[]...
  • placement new和placement delete参考:《Effective C++》placement new和placement delete 1 什么是placement new和placement delete 2 如何使用placement版本的newdelete 3 从内存泄露出发 a 什么时候new一个...
  • 大家都知道newdeletenew[]和delete[]要配对使用,但并不是所有人都知道deletedelete[]究竟有什么区别。有人会说delete不就是删除对象,delete不就是删除数组的嘛。这样的说法应该只能说对了一半。的确,delete...
  • c++ new and delete

    千次阅读 2006-03-31 23:53:00
    c++中的new/deletenew/delete究竟做了些什么? 在理解这个问题之前,我们先看一下下面的这段程序,有这么一个程序段: class A { public: A() { cout!"; } ~A(){ cout!"; }
  • 关于new/delete存在两种情况,一种是new/delete operator和operator new/delete。那么两者有什么区别呢?  我们一般使用的new/delete都是语言内建的操作符,即new operator,类似于sizeof,所以被改变意义,它是不...
  • new/deletenew[]/delete[]实现机制

    千次阅读 2017-02-18 21:48:10
    newdelete是C++新引入的单目运算符,它们可以从堆上分配和删除存储块(堆在C++中也叫自由存储).用new运算符(不是函数)时要指明数据类型,以后new就分配一个足以放下指明类型对象的存储,并返回该存储块的首地址作为...
  • newdelete

    2018-08-01 21:49:05
    在c++中动态申请空间使用的函数是new,释放使用delete,我们先来看一下如何使用, 这是一个整型指针四字节空间开辟的代码,释放时直接跟变量名。可以看出使用new比malloc要简单的多 New的底层实现其实也是调用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,685
精华内容 24,674
关键字:

deletenew