delete_deleted - CSDN
delete 订阅
delete是指删除,常用于编程语言中(C++,SQL等等)。过去式:deleted;过去分词:deleted;现在分词:deleting;第三人称单数:deletes 展开全文
delete是指删除,常用于编程语言中(C++,SQL等等)。过去式:deleted;过去分词:deleted;现在分词:deleting;第三人称单数:deletes
信息
外文名
delete
现在分词
deleting
过去式
deleted
中文名
删除
应用领域
编程
delete基本信息
/di`li:t/v.tr.remove or obliterate(written or printed matter),通过esp.by striking out(尤指划掉)删除,删去(手写话印刷内容)[Latin delēre delet-'efface']对于文件名shift+delete可彻底删除。按住 SHIFT 键再单击“关闭”按钮(一般适用)
收起全文
  • delete用法

    2018-10-22 18:04:48
    delete删除行 1,删除某行 delete from 表名 where 列名称=列值 如:delete from n1 where name=0 或 where name is null 2,删除全部行 delete from 表名(类似与清空表,不改变表结构) delete * from 表名 ...

    delete删除行
    1,删除某行
    delete from 表名 where 列名称=列值
    如:delete from n1
    where name=0 或 where name is null

    2,删除全部行
    delete from 表名(类似与清空表,不改变表结构)
    delete * from 表名

    展开全文
  • c++中对new申请的内存的释放方式有deletedelete[两种方式,到底这两者有什么区别呢? 1.我们通常从教科书上看到这样的说明: delete 释放new分配的单个对象指针指向的内存 delete[] 释放new分配的对象数组...

    c++中对new申请的内存的释放方式有delete和delete[两种方式,到底这两者有什么区别呢?

    1.我们通常从教科书上看到这样的说明:
    delete 释放new分配的单个对象指针指向的内存
    delete[] 释放new分配的对象数组指针指向的内存
    那么,按照教科书的理解,我们看下下面的代码:
    int *a = new int[10];
    delete a;        //方式1
    delete [] a;     //方式2
    肯定会有很多人说方式1肯定存在内存泄漏,是这样吗?

    (1). 针对简单类型 使用new分配后的不管是数组还是非数组形式内存空间用两种方式均可 如:
       int *a = new int[10];
       delete a;
       delete [] a;
       此种情况中的释放效果相同,原因在于:分配简单类型内存时,内存大小已经确定,系统可以记忆并且进行管理,在析构时,系统并不会调用析构函数,
       它直接通过指针可以获取实际分配的内存空间
    ,哪怕是一个数组内存空间(在分配过程中 系统会记录分配内存的大小等信息,此信息保存在结构体_CrtMemBlockHeader中,
       具体情况可参看VC安装目录下CRT\SRC\DBGDEL.cpp)

    (2). 针对类Class,两种方式体现出具体差异 
       当你通过下列方式分配一个类对象数组:
       class A
       {
       private:
          char *m_cBuffer;
          int m_nLen;
       public:
          A(){ m_cBuffer = new char[m_nLen]; }
          ~A() { delete [] m_cBuffer; }
       };
       A *a = new A[10];
       delete a;         //仅释放了a指针指向的全部内存空间 但是只调用了a[0]对象的析构函数 剩下的从a[1]到a[9]这9个用户自行分配的m_cBuffer对应内存空间将不能释放 从而造成内存泄漏
       delete [] a;      //调用使用类对象的析构函数释放用户自己分配内存空间并且   释放了a指针指向的全部内存空间

    所以总结下就是,如果ptr代表一个用new申请的内存返回的内存空间地址,即所谓的指针,那么:
       delete   ptr   代表用来释放内存,且只用来释放ptr指向的内存。 
       delete[]   rg   用来释放rg指向的内存,!!还逐一调用数组中每个对象的destructor!!
       对于像int/char/long/int*/struct等等简单数据类型,由于对象没有destructor,所以用delete 和delete [] 是一样的!但是如果是C++对象数组就不同了!

    关于 new[] 和 delete[],其中又分为两种情况:(1) 为基本数据类型分配和回收空间;(2) 为自定义类型分配和回收空间。 

    对于 (1),上面提供的程序已经证明了 delete[] 和 delete 是等同的。但是对于 (2),情况就发生了变化。

    我们来看下面的例子,通过例子的学习了解C++中的delete和delete[]的使用方法

    #include <iostream>
    using namespace std;
    /////////class Babe
    class Babe
    {
    public:
        Babe()
        {
            cout << \"Create a Babe to talk with me\" << endl;
        }
        ~Babe()
        {
            cout << \"Babe don\'t go away,listen to me\" << endl;
        }
    };
    //////////main function
    int main()
    {
        Babe* pbabe = new Babe[3];
        delete pbabe;
        pbabe = new Babe[3];
        delete pbabe[];
        return 0;
    }


    结果是:

    Create a babe to talk with me

    Create a babe to talk with me

    Create a babe to talk with me

    Babe don\'t go away,listen to me

    Create a babe to talk with me

    Create a babe to talk with me

    Create a babe to talk with me

    Babe don\'t go away,listen to me

    Babe don\'t go away,listen to me

    Babe don\'t go away,listen to me

    =================================================

    大家都看到了,只使用delete的时候只出现一个 Babe don\'t go away,listen to me,而使用delete[]的时候出现3个 Babe don\'t go away,listen to me。不过不管使用delete还是delete[]那三个对象的在内存中都被删除,既存储位置都标记为可写,但是使用delete的时候只调用了pbabe[0]的析构函数,而使用了delete[]则调用了3个Babe对象的析构函数。你一定会问,反正不管怎样都是把存储空间释放了,有什么区别。答:关键在于调用析构函数上。此程序的类没有使用操作系统的系统资源(比如:Socket、File、Thread等),所以不会造成明显恶果。如果你的类使用了操作系统资源,单纯把类的对象从内存中删除是不妥当的,因为没有调用对象的析构函数会导致系统资源不被释放,如果是Socket则会造成Socket资源不被释放,最明显的就是端口号不被释放,系统最大的端口号是65535(216 _ 1,因为还有0),如果端口号被占用了,你就不能上网了,呵呵。如果File资源不被释放,你就永远不能修改这个文件,甚至不能读这个文件(除非注销或重器系统)。如果线程不被释放,这它总在后台运行,浪费内存和CPU资源。这些资源的释放必须依靠这些类的析构函数。所以,在用这些类生成对象数组的时候,用delete[]来释放它们才是王道。而用delete来释放也许不会出问题,也许后果很严重,具体要看类的代码了.



    展开全文
  • delete

    2018-07-25 11:39:25
    #define _CRT_SECURE_NO_WARNINGS #include &lt;iostream&gt; #include &lt;vector&... /*对于提供了默认构造函数的类类型如string,没有必要对其对象进行值初始化:无论程序明确初始化还是不初始化....
    #define _CRT_SECURE_NO_WARNINGS
    
    
    #include <iostream>
    #include <vector>
    #include <bitset>
    using namespace std;
    
    int main()
    {
    	/*对于提供了默认构造函数的类类型如string,没有必要对其对象进行值初始化:无论程序明确初始化还是不初始化,都会自动调用默认构造寒素初始化对象*/
    	string *ps = new string;  //初始化为空string
    	string *ps2 = new string();//初始化为空string
    	string *ps3 = new string(2, '2');  //*ps2 = "22"
    	delete ps, ps2, ps3;
    	ps = ps2 = ps3 = 0; //ps = ps2 = ps3类型相同。
    	int x0(0);   //x0 = 0;
    	int x();  //声明一个函数x,没有参数,返回值为int
    			  
    
    	int *pi = new int;  //不初始化:内置类型
    	int *p2 = new int();  //初始化为0  
    	delete pi, p2;  //如果指针指向的不是new分配的地址,就是不合法的
    	pi = p2 = 0; 
    	//如果new表达式无法获取需要的内存,就会bad_alloc异常。
    	int *sa = new int[10];  //sa指向数组
    	delete[] sa;    //删除数组指针
    	sa = 0;
    	string str = "malloc";
    	//delete str; 如果指针指向的不是new分配的地址,就是不合法的
    	int i;
    	int *pid = &i;
    //	delete pid;  //会触发异常
    
    	int *ip = 0;
    	delete ip;   //可以删除0值的指针但是无意义。
    	ip = 0;
    	system("pause");
    }

    总结:delete只能删除new分配的地址,delete[]用来删除栈上数组

    delete 之后,重设指针的值为0:

    delete p之后,p变成没有意义。在很多机器上,尽管p没有意义,但是仍然存放了之前所指向的对象的地址,然而p所指向的内存已经被释放,因此p不再有效。删除指针之后,该指针变成悬垂指针。悬垂指针指向曾经存放对象的内存,但该对象已经不再存在了。会导致程序错误。因此一旦删除了指针所指向的对象,需要历经将指针置0

    展开全文
  • 在 C++ 中,你也许经常使用 new 和 delete 来动态申请和释放内存,但你可曾想过以下问题呢? new 和 delete 是函数吗?new [] 和 delete [] 又是什么?什么时候用它们?你知道 operator new 和 operator delete 吗...

    在 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[](size_t);     //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 背后完成的工作:

    简单总结一下:

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

    所有这三步,你都可以通过反汇编找到相应的汇编代码,在这里我就不列出了。

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

    delete pA;
    

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

    delete 就做了两件事情:

    1. 调用 pA 指向对象的析构函数,对打开的文件进行关闭。
    2. 通过上面提到的标准库函数 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++ Primer 第四版

    展开全文
  • 以前看书的时候,书上说使用new申请的内存,释放时用delete,使用new [ ]申请的内存释放时要用delete [ ]才行,这两个一定要记住,申请时用了方括号,则释放时也要加上方括号,否则就会出错。但是并没有解释为什么...
  • delete删除数据

    2018-06-11 20:18:24
    1. 删除数据由于参照完整性约束,有些记录不能删除,所以我们这里不考虑参照完整性约束 语法: delete表名 [WHERE &lt;逻辑表达式&gt;] 同样是对lead表进行删除 (1).删除所有数据delete 表名 即可删除...
  • 为何new出的对象数组必须要用delete[]删除,而普通数组deletedelete[]都一样 文章中验证了 对象数组 用 delete 删除不行(因为对象数组中还有记录一个元素大小的4个字节字段,delete函数内操作的内存中会有4个...
  •  一切好象都井然有序——一个new对应着一个delete——然而却隐藏着很大的错误:程序的运行情况将是不可预测的。至少,stringarray指向的100个string对象中的99个不会被正确地摧毁,因为他们的析构函数永远不会被...
  • delete 释放new分配的单个对象指针指向的内存 delete[] 释放new分配的对象数组指针指向的内存 那么,按照教科书的理解,我们看下下面的代码: int *a = new int[10]; delete a; //方式1 delete [] a; //方式2 肯定...
  • C ++ deletedelete[]

    2012-05-18 14:46:51
    C++告诉我们在回收用 new 分配的单个对象的内存空间的时候用 delete,回收用 new[] 分配的一组对象的内存空间的时候用 delete[]。  关于 new[] 和 delete[],其中又分为两种情况:(1) 为基本数据类型分配和回收...
  • c++中对new申请的内存的释放方式有deletedelete[两种方式,到底这两者有什么区别呢?   1.我们通常从教科书上看到这样的说明: delete 释放new分配的单个对象指针指向的内存 delete[] 释放new分配的对象数组...
  • 今天用到了数组的删除,分别使用了splice和delete方法,记录一下,方便下次查找。原数组是一个关联数组,如var test=[];test[1]={name:'1',age:1};test[2]={name:'2',age:2};test[4]={name:'3',age:3};console.log...
  • mac和windows区别在Windows电脑中,有两个键可以实现删除的功能,一个是画着←的BackSpace退格键,一个是Delete键。退格键可以删除光标左边的文字,Delete键可以删除光标右边的文字,也可以用来删除文件。而在Mac...
  • C++标准规定:delete空指针是合法的,没有副作用。 所以我们在Delete指针后赋值为NULL或0是个好习惯。对一个非空指针delete后,若没有赋NULL,若再次delete的话 有可能出现问题。如下代码: 可以看出delete是释放...
  • drop、truncate和delete的区别 (1)DELETE语句执行删除的过程是每次从表中删除一行,并且同时将该行的删除操作作为事务记录在日志中保存以便进行进行回滚操作。  TRUNCATE TABLE 则一次性地从表中删除所有的...
  • C++ delete报错原因

    2014-01-13 23:19:44
    C++ delete报错原因释放内存两种方式:new deletenew [] delete []出错现象:1.执行delete语句时,程序直接弹窗,崩溃。2.执行delete语句时,程序卡死。将delete语句注释掉,又正常了,但发生了内存泄露。原因分析:1....
  • 在对接的过程中,鄙人不才,一般都是用的POST和GET的请求居多,确实对DELETE请求接触不多,这次后台的大兄弟就直接让我提交DELETE请求来进行实体的删除操作。那就来呗,不就是和POST差不多嘛,代码如下: @DELETE(...
  • vue中axios 的delete和post,put在传值上有点区别; post和put有三个参数,url,data和config,所以在使用这两个时,可以写成axios.post(api,{id:1}),axios.put(api,{id:1}),但是delete只有两个参数:url和config,data...
  • 一、什么时候用new[]申请,可以用delete释放 1、在C++中,把单个元素的内存开辟释放和数组的内存开辟释放是分开的。因为在C++里面,开辟内存和构造对象是一起发生的,析构对象和释放内存是一起发生的 int *a = ...
  • 最近在为一个Base项目实现需求,看到了大量的重载operator new/delete的轮子代码,而这方面之前并没有过多去关注,于是花了点时间,查一查资料,写了写Demo的代码,总算是对C++中new/delete这一家族的成员有了个了解...
1 2 3 4 5 ... 20
收藏数 1,792,951
精华内容 717,180
关键字:

delete