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 表名

    展开全文
  • deletedelete []的真正区别

    万次阅读 多人点赞 2014-08-28 17:18:58
    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来释放也许不会出问题,也许后果很严重,具体要看类的代码了.



    展开全文
  • C++中的deletedelete[ ]的区别

    万次阅读 多人点赞 2018-07-04 23:24:00
    以前看书的时候,书上说使用new申请的内存,释放时用delete,使用new [ ]申请的内存释放时要用delete [ ]才行,这两个一定要记住,申请时用了方括号,则释放时也要加上方括号,否则就会出错。但是并没有解释为什么...

    以前看书的时候,书上说使用new申请的内存,释放时用delete,使用new [ ]申请的内存释放时要用delete [ ]才行,这两个一定要记住,申请时用了方括号,则释放时也要加上方括号,否则就会出错。但是并没有解释为什么这样,会出什么错。今天正好看到这个,记录下。

    关于动态申请的内存,分两种情况:基本数据类型的分配和自定义数据类型的分配。两者不同。

    1、基本数据类型

     对于基本数据类型,假如有如下代码

    int *a = new int[10];

    ...

    delete a;    // 方式1

    delete [ ] a;    //方式2

    肯定会不少人认为方式1存在内存泄露,然而事实上是不会!针对简单的基本数据类型,方式1和方式2均可正常工作,因为:基本的数据类型对象没有析构函数,并且new 在分配内存时会记录分配的空间大小,则delete时能正确释放内存,无需调用析构函数释放其余指针。因此两种方式均可。

    2、自定义数据类型

    这里一般指类,假设通过new申请了一个对象数组,注意是对象数组,返回一个指针,对于此对象数组的内存释放,需要做两件事情:一是释放最初申请的那部分空间,二是调用析构函数完成清理工作。对于内存空间的清理,由于申请时记录了其大小,因此无论使用delete还是delete[ ]都能将这片空间完整释放,而问题就出在析构函数的调用上,当使用delete时,仅仅调用了对象数组中第一个对象的析构函数,而使用delete [ ]的话,将会逐个调用析构函数。


    有如下代码:

    #include <iostream>;
    using namespace std;
    
    class T {
    public:
      T() { cout << "constructor" << endl; }
      ~T() { cout << "destructor" << endl; }
    };
    
    int main()
    {
      const int NUM = 3;
    
      T* p1 = new T[NUM];
      cout << hex << p1 << endl;      //输出P1的地址
      //  delete[] p1;
      delete p1;
    
      cout << endl;
    
      T* p2 = new T[NUM];
      cout << p2 << endl;             //输出P2的地址
      delete[] p2;
    
      return 0;
    }

    输出结果为


    可以看到,不加[ ]符号时确实只调用了一次析构函数。

    问题来了,既然不加方括号也能完整释放内存,那不就没多调用几个析构函数吗,怎么了?想想看,万一析构函数需要释放系统资源呢?比如文件?线程?端口?这些东西使用了而不释放将会造成严重的后果。因此,虽然内存完整的释放了,但是有时候不调用析构函数则会造成潜在的危险。

    所以new的时候使用了[ ],那么delete的时候还是使用[ ]吧!


    展开全文
  • 浅谈 C++ 中的 new/delete 和 new[]/delete[]

    万次阅读 多人点赞 2014-03-18 08:47:18
    在 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 第四版

    展开全文
  • drop与delete的区别

    万次阅读 多人点赞 2019-11-21 10:23:11
    drop与delete的区别: 初学sql语言,难免被drop和delete用法弄混,二者都有删除的意思。那它们又有什么区别呢? drop主要用于删除结构 例如删除数据库:drop database XX,删除表 drop table XX。字段...
  • 近日遇到一个比较奇怪的deadlock错误, 错误详情: Deadlock found when trying to get lock; try restarting transaction; nested exception is ... 跟踪代码后最终定位到一段业务逻辑: delete...
  • 一、死锁案例 ...业务逻辑:并发下按某个索引字段先delete记录,再insert记录 比如: begin; delete from tb where order_id = xxx; insert into tb(order_id) values(xxx); commit; 二、MySQL锁...
  • 【mysql】死锁-产生原因和解决方法

    万次阅读 2018-08-15 09:25:06
    最近总结了一波死锁问题,和大家分享一下,我这也是从网上各种浏览博客得来,希望原作者见谅,参考博客地址都在下方。   一、Mysql 锁类型和加锁分析   1、锁类型介绍:  ...MySQL有三种锁的级别:页级、表级、...
  • 关于mysql事务引发的死锁异常解决场景问题死锁日志[^2]锁类型与隔离级别InnerDB 锁:mysql事务解决方案 场景 mysql 5.7 InnoDB存储引擎 jdk 8 springboot hikari 连接池 spring: application: ...
  • C ++ deletedelete[]

    千次阅读 2012-05-18 14:46:51
    C++告诉我们在回收用 new 分配的单个对象的内存空间的时候用 delete,回收用 new[] 分配的一组对象的内存空间的时候用 delete[]。  关于 new[] 和 delete[],其中又分为两种情况:(1) 为基本数据类型分配和回收...
  • C++中 =defaule 和 =delete 使用

    万次阅读 2018-04-22 01:26:48
    编译器默认为一个类生成的默认函数 默认构造函数 默认析构函数 默认拷贝构造函数 默认赋值函数 移动构造函数 移动拷贝函数 class DataOnly { public: DataOnly () // default constructor ... ...
  • 深入理解JS的delete

    万次阅读 2014-09-14 23:41:36
    几周之前,我有幸拜读斯托诺夫(Stoyan Stefanov) 的 Object-Oriented Javascript 一书.(该书在亚马逊得到非常高的评分,12个五星评价.译注:亚马逊是最有节操的网上书店,评论基本上都很真实靠谱),所以我很好奇,想看看有...
  • delete p和delete[] p的区别

    千次阅读 2009-11-07 20:45:00
    原文: operator new 和 operator delete函数有两个重载版本,每个版本支持相关的new表达式和delete表达式: void* operator new (size_t); // allocate an object void* operator new [] (size_t); // ...
  • new/delete 详解

    万次阅读 2016-11-09 21:18:18
    new 和 delete 是 C++ 用于管理 堆内存</font> 的两个运算符,对应于C语言中的 malloc 和 free,但是malloc和free是函数,new 和 delete 是运算符。
  • delete后加 limit是个好习惯么

    万次阅读 多人点赞 2020-10-22 12:09:41
    在业务场景要求高的数据库中,对于单条删除和更新操作,在delete和update后面加limit 1绝对是个好习惯。比如,在删除执行中,第一条就命中了删除行,如果SQL中有limit 1;这时就return了,否则还会执行完全表扫描才...
  • C++ delete报错原因

    万次阅读 2020-08-29 11:34:18
    C++ delete报错原因释放内存两种方式:new deletenew [] delete []出错现象:1.执行delete语句时,程序直接弹窗,崩溃。2.执行delete语句时,程序卡死。将delete语句注释掉,又正常了,但发生了内存泄露。原因分析:1....
  • C++ new和delete的原理分析

    千次阅读 2017-08-30 07:37:28
    前言Effective C++ rule 16规则,让我重新认识了delete与new在处理数组时候的方式。new 有两种形式的new,一种是生成一个对象的operator New,另一个是用于数组的operator new []。同时 operator delete也分普通版本的...
  • elasticsearch 基础 —— Delete By Query API

    千次阅读 2018-09-14 14:36:36
    Delete By Query API _delete_by_query 的简单用法,就是在查询匹配到的每个文档上执行删除。例如: POST twitter/_delete_by_query { "query": { ① "match": { "message": &...
  • 释放对象数组:deletedelete[]

    万次阅读 2010-10-10 00:23:00
      delete parray;  delete [] parray;  方括号的存在会使编译器获取数组大小(size)然后析构函数再被依次应用在每个元素上,一共size次。否则,只有一个元素被析构。  无论哪种情况,...
  • truncate与delete的区别

    万次阅读 2019-03-10 11:15:44
    最近到了系统开发后期,需要对数据进行按时间备份。备份完成后对之前数据表的处理就只有删除了,突然查下...这种快速删除与delete from 数据表的删除全部数据表记录不一样,delete命令删除的数据将存储在系统回滚...
1 2 3 4 5 ... 20
收藏数 1,971,245
精华内容 788,498
关键字:

delete