精华内容
下载资源
问答
  • C/C++ 动态内存分配

    万次阅读 多人点赞 2019-06-30 18:03:06
    首先我们看看 c 语言是如何进行动态内存分配的; c 语言主要是使用malloc / calloc / realloc 来进行内存申请的。 malloc / realloc / calloc三者的共同点与不同点: 共同点 1、都是从堆上进行动态内存分配 2、...

    转自:https://blog.csdn.net/Code_beeps/article/details/89625473#comments

    首先我们看看 c 语言是如何进行动态内存分配的;
    c 语言主要是使用malloc / calloc / realloc 来进行内存申请的。
    malloc / realloc / calloc三者的共同点与不同点:

    共同点

    都是从堆上进行动态内存分配
    释放内存都是需要使用free函数来释放
    三者的返回值都是void*
    都需要强制类型转换
    都需要对申请出的空间判空(因为申请内存失败会返回空)
    

    不同点:
    1)void *malloc( size_t size );
    malloc的参数是用户所需内存空间大小的字节数,不会对申请成功的内存初始化。
    malloc 申请空间时并不是需要多少就申请多少,而是会多申请一些空间,1)多申请一个32字节的结构体,里面对申请的空间进行描述,2)在申请的空间前后会各多申请 4 个字节的空间,这就是保护机制,当你操作不当越界了,这 8 个字节的内容会改变,操作系统会检查前后 4 个字节是否改变了,以此判断是否越界了。

    在这里插入图片描述
    在这里插入图片描述
    2)void *calloc( size_t num, size_t size );
    calloc的参数:第一个:元素的个数,第二个:单个元素所占字节;会把申请成功的空间初始化为 0

    3)void *realloc( void *ptr, size_t size );
    realloc的参数:第一个:地址,第二个:字节数
      对于 realloc 的第一个参数:
        如果指向空,那么此时realloc 就和 malloc 是一样的;
        如果不为空,那么就将即将要申请的空间与原空间进行比较。
            如果要申请的空间比原空间小,就将原空间缩小,并返回原空间首地址
            如果要申请的空间比原空间大,那么分两种情况:
            第一种:新旧空间之差小于原空间大小,直接在原空间进行延伸,并返回原空间的首地址。
            第二种:新旧空间之差大于原空间的大小,那么直接开辟新空间,并将原空间的数据拷贝到新空间,并返回新空间首地址。
    在这里插入图片描述
    看完了 C 动态内存管理,那么来看看C++的动态内存管理:
    首先 C 语言中的动态内存管理方式在 C++ 中仍然可以使用。c++ 中多了 new 这个操作符。
    new申请的空间:

    1、不用强制类型转换;
    2、不用对申请出来的空间进行判空;
    3、可以申请时初始化这段空间。
    

    malloc / new / new[] 和 free / delete / delete[]
    对于内置类型:如果没有配合使用,可能不会出现什么问题。
    对于自定义类型:
      malloc:只是将空间动态开辟成功,并不会调用构造函数初始化空间。
      free:只是将申请的空间进行释放,并不会调用析构函数清理对象中的资源

    new:先将对象的空间开辟成功,然后调用构造函数完成对象的初始化。
      delete:先调用析构函数将对象中的资源清理,然后释放对象占用的空间
    如果对一个内部有资源的自定义类型使用 malloc 开辟内存,此时调用 delete 进行空间的释放,程序就会崩溃。因为 malloc 只负责开辟空间,并不会调用对象的构造函数对其成员变量进行初始化,那么内部的成员变量是没有分配空间的,当我们调用 delete 时,delete会先对对象进行资源清理,但是对象里的资源 malloc 并没有给其分配,所以我们清理的时候是非法的操作。导致程序崩溃。

    对于内部有资源的自定义类型,使用 new 开辟的空间使用 free 释放,会造成内存泄漏,因为 free 并不会调用析构函数清理对象的资源,因此会造成资源泄漏。

    new底层的流程:

    第一步:调用operator new() 来申请空间
    第二步:调用该类的构造函数
    

    operator new() 的工作流程:
    比如 new T:底层调用 void* operator new(sizeof(T)),申请 T 类型大小的堆空间。
      在这个函数中是循环调用 malloc :

      1、申请空间成功:返回空间的首地址。
      2、申请空间失败:检测用户是否提供空间不足的应对措施?如果提供应对措施,则执行应对措施,否则直接抛出 bad_alloc 类型的异常。
    

    在这里插入图片描述
    new[]的流程:
    第一步:调用void* operator new[](count = sizeof(T) * N + 4),如果T类的析构函数显式提供就多申请4个字节。(多申请的四个字节就是用来保存对象的个数,可以知道未来需要调用几次析构函数。)
      这里operator new 的运行流程和上图一致。
    第二步:将空间前四个字节填充对象的个数,然后调用构造函数构造 N 个 T 类型对象。

    delete的流程:
    第一步:调用析构函数清理对象中的资源。
    第二步:调用void operator delete(void* p)释放空间,void operator delete(void* p)中调用的是 free 释放空间。

    delete[] 的流程:
    第一步:从第一个对象空间之前的4个字节中取对象的个数N
    第二步:调用N次析构函数倒着释放(栈的特性)
    第三步:void operator delete[](void* p)----这个p就是真正使用位置倒退4个字节的位置,也就是申请的空间的首地址。
    在这里operator delete[](void* p) 调用 void operator delete(void* p) 调用 free()

    综上:operator new 和 operator delete 实际上是由 malloc 和 free 来实现的,是对malloc 和 free 的封装。

    malloc/free 和 new/delete 区别:
    共同点:都在堆上申请空间,都需要手动申请 / 释放空间。
    不同点:

      1)malloc/free 是函数,new/delete是标识符
      2)malloc 不会对对象进行初始化,new 可以初始化
      3)malloc 申请空间时,需要手动计算需要申请空间的大小,而new只需在后面跟上类型,编译器会自动计算大小。
      4)malloc 返回值是 void*,使用时必须要强制类型转换,而 new 并不需要强制类型转换,因为new后跟的就是类型。
      5)malloc 申请空间失败返回 NULL,因此使用时必须判空,new不需要判空,但是需要捕获异常
      6)申请自定义类型对象时,malloc/free只会开辟空间,并不调用构造/析构函数,而 new 是先申请空间,
      然后调用构造函数完成对象的初始化,delete 在释放空间前会先清理对象占用的资源。
      7)malloc/free 的效率会比 new/delete 的高,因为 new/delete 中封装的是malloc/free。
    
    展开全文
  • 首先我们先了解一下内存:C语言使用malloc/free动态管理内存空间,C++引入了new/delete,new[]/delete[]来动态管理内存。 介绍new/delete,new[]/delete[]之前我们先了解一下operator new,operator delete,...

    首先我们先了解一下内存:

    这里写图片描述

    C语言使用malloc/free动态管理内存空间,C++引入了new/delete,new[]/delete[]来动态管理内存。
    介绍new/delete,new[]/delete[]之前我们先了解一下operator new,operator delete,operator new[],operator delete[]函数。

    注:这些函数并没有重载new/delete表达式。

    函数声明如下:
    void* operator new(size_t size);
    void operator delete(size_t size);
    void* operator new[](size_t size);
    void operator delete[](size_t size);
    
    析:operator new/operator delete,operator new[]/operator delete[]是标准库函数,用法和malloc/free的用法一样,只负责分配/释放空间,但实际上operator new/operator delete只是malloc/free的一层封装。

    new/delete:动态管理对象;
    new[]/delete[]动态管理对象数组。

    int* ptr1=new int;//动态分配4个字节的空间
    delete ptr;
    int* ptr2=new int(4);//动态内存分配4个字节空间并初始化
    delete ptr2;
    int* ptr3=new int[4];//动态内存分配16个字节空间
    delete[];

    1>,new/delete实际上做了什么事呢??
    new:先调用operator new分配空间,再调用构造函数初始化空间。
    delete:先调用析构函数清理对象,再调用operator delete释放空间。

    这里写图片描述
    这里写图片描述

    2>,new[]/delete[]实际上做了什么事呢??
    new[n]:调用operator new分配空间,再调用n次构造函数初始化对象。
    delete[n]:调用n次析构函数清理对象,再调用operator delete释放空间。

    这里写图片描述

    为什么编译器会知道调用多少次构造函数,析构函数呢?
    原来在new[ ]分配空间的时候会在头部多分配4个字节来存n,这样在调用new[]/delete[]时就知道调用几次构造函数和析构函数了。

    new/delete,new[]/delete[]为什么要成对出现?
    当new在开辟内置类型的空间时,不成对出现是可以的;但是当开辟非内置类型空间时,就要多开辟4个字节,这时如果不成对使用就会造成内存泄漏或者程序崩溃。
    这里写图片描述

    用宏模拟实现new[]/delete[]申请和释放数组

    //DELETE_ARRAY参数中传n
    #define NEW_ARRAY(ptr,type,n)                          
    do{                             
    ptr=(type*)operatornew(sizeof(type)*n);             
    for (size_t i = 0; i <n;++i)                            
    {                       
    new(ptr+i)type;                     
    }                                                       
    } while (0);                                            
    
    
    #define DELETE_ARRAY(ptr,type,n)                
    do{                             
    for (size_t i = 0; i < n; ++i)                          
    {               
    (ptr+i)->~String();                        
    }                               
    operator delete ptr;                                
    } while (0);
    //给DELETE_ARRAY中不传n
    #define NEW_ARRAY(ptr,type,n)                           
    do{                                                                             
    ptr = (type*)operator new(sizeof(type)*n + 4);           //给n也分配空间
    *(int*)ptr = n;                                             
    ptr=(type*)((char*)ptr+4);                                  
    for (size_t i = 0; i < n; ++i)                              
    {                                                       
    new(ptr + i)(type);                                 
    }                                                           
    } while (0);
    
    #define DELETE_ARRAY(ptr,type)                              
    do{                                                         
        size_t n = *((int*)ptr - 1);                            
        for (size_t i = 0; i < n; ++i)                              
        {                                                           
        (ptr + i)->~String();                                  
        }                                                           
        operator delete(char*(ptr - 4));                            
    } while (0);

    malloc/free和new/delete之间关系和差异
    关系:都能进行动态内存管理。
    差异:1>,malloc/free是标准的库函数, new/delete是操作符;
    2>,malloc/free只是分配/释放内存 ,new/delete不仅分配/释放内存还调用构造函数初始化和析构函数清理;
    3>,malloc/free手动计算类型大小,返回值void*,new/delete自动计算类型大小,返回对应类型的指针;
    4>,malloc/free失败返回0, new/delete失败抛异常。

    展开全文
  • C++动态内存会被自动释放吗?

    千次阅读 2019-01-04 23:00:13
    C++动态内存会被自动释放吗?  函数体内的局部变量在函数结束时自动消亡。很多人误以为示例7-6是正确的。理由是p是局部的指针变量,它消亡的时候会让它所指的动态内存一起完蛋。这是错觉!    void Func...

    C++动态内存会被自动释放吗?

           函数体内的局部变量在函数结束时自动消亡。很多人误以为示例7-6是正确的。理由是p是局部的指针变量,它消亡的时候会让它所指的动态内存一起完蛋。这是错觉!

     

        void Func(void)

    {

        char *p = (char *) malloc(100); // 动态内存会自动释放吗?

    }

    示例7-6 试图让动态内存自动释放

     

        我们发现指针有一些“似是而非”的特征:

    (1)指针消亡了,并不表示它所指的内存会被自动释放。

    (2)内存被释放了,并不表示指针会消亡或者成了NULL指针。

    这表明释放内存并不是一件可以草率对待的事。也许有人不服气,一定要找出可以草率行事的理由:

        如果程序终止了运行,一切指针都会消亡,动态内存会被操作系统回收。既然如此,在程序临终前,就可以不必释放内存、不必将指针设置为NULL了。终于可以偷懒而不会发生错误了吧?

        想得美。如果别人把那段程序取出来用到其它地方怎么办?

    展开全文
  • PCL之C++动态内存学习

    千次阅读 2018-05-09 21:12:35
    在PCL 的点云库中大量的使用动态内存的方式编程,比如: pcl::PCLPointCloud2::Ptr cloud (new pcl::PCLPointCloud2 ()); PointCloudT::Ptr cloud = boost::shared_ptr &amp;lt;PointCloudT&amp;gt; (new ...

    在PCL 的点云库中大量的使用动态内存的方式编程,比如:

    pcl::PCLPointCloud2::Ptr cloud (new pcl::PCLPointCloud2 ());
    PointCloudT::Ptr cloud = boost::shared_ptr <PointCloudT> (new PointCloudT ());
    boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer (new pcl::visualization::PCLVisualizer ("3D Viewer"));

    第一行是申明一

    展开全文
  • 动态内存分配C++实例

    2011-10-08 08:31:01
    一道经典的作业题,耗费我无数昼夜,在这里拿出来给大家分享下
  • C++ 动态内存管理

    千次阅读 2017-07-23 00:10:45
    (3)从堆或自由存储空间上分配,亦称为动态内存分配,如malloc函数和new运算符申请的内存(使用free和delete释放动态内存)。2、常见的内存错误及其对策 (1)错误:内存分配未成功,却使用了它。 对策:在使用...
  • 【带你吃透C++C++动态内存管理

    千次阅读 多人点赞 2022-01-19 14:26:12
    作为一名编程初学者,通常学习中,发生内存错误是件非常麻烦的事情。编译器不能自动发现...本文主要针对C++动态内存管理内容进行分享,如果想了解C语言动态内存管理可以参考:【C语言进阶】动态内存管理(详细介绍)
  • C++动态内存分配(堆)

    千次阅读 2015-07-24 11:36:34
    C/C++定义了4个内存区间:  代码区,全局变量与静态变量区,局部变量区即栈区,动态存储区,即堆(heap)区或自由存储区(free store)。 堆的概念: 通常定义变量(或对象),编译器在编译时都可以根据该变量...
  • C++动态内存管理

    千次阅读 2018-07-12 01:23:19
    操作系统内存分配与管理 操作系统是运行在系统上的软件。负责进程管理,存储管理,设备管理,文件管理等系统功能。具有并发,共享,随机三个主要特征。然而存储管理的核心是合理分配内存空间。内存是可被处理器直接...
  • C++ 动态分配内存的好处

    千次阅读 2020-05-16 20:26:47
    实例化一个类有两种方式: // 假设有一个类A ...方式二则是在堆区(动态内存,大小任意,手动释放)分配一块内存,然后用指针a去指向这块内存; 那么我们很容易就知道为什么要使用动态内存分配来实例化
  • 使用C/C++编程时,会经常开辟内存空间,以便动态合理使用内存,本文主要讲述开辟内存空间的几种方法及一些原理,理解不深刻之处欢迎各位指正。 概述 需要用到头文件<stdlib.h> malloc calloc realloc new free...
  • 说到C++动态内存分配,我们首先都会想到new和delete运算符,new运算符可以分配并初始化一个对象或对象数组,并返回指向数组第一个对象的指针。而delete运算符则逐个销毁(根据对象数组倒序执行析构函数)对象并回收...
  • C/C++动态内存管理—(new与malloc)

    千次阅读 多人点赞 2021-03-14 20:57:43
    文章目录1.C/C++内存分布2.C语言动态内存分配2.1 malloc2.2 calloc2.3 realloc2.4 free3.C语言动态内存代码示例4.C++动态内存分配4.1 new4.1.1 operator new4.2 delete4.2.1 operator delete5.C++动态内存代码示例6....
  • 浅析C++中的动态内存分配

    千次阅读 多人点赞 2018-04-09 15:28:58
    在C语言中,我们学到了使用malloc/calloc/relloc来进行内存动态开辟,用free来完成内存的释放。而在C++中是通过new和delete这两个操作符来实现的。当然C++中也可以使用C语言那套内存管理的方法,毕竟C++是兼容...
  • C/C++动态内存管理malloc/new、free/delete的异同

    千次阅读 多人点赞 2018-07-12 20:41:17
    学习了C和C++之后,我们都知道这两种语言皆有动态内存管理,两者之间异同,我们需要系统的总结一下! 一、相同 两者都可以用来动态申请内存和释放内存; 二、不同 1.malloc/free是C/C++标准库的函数,new/...
  • C++中类的动态内存分配与释放

    千次阅读 2019-09-21 22:01:09
      一般来讲,编译器使用三块独立的内存:   1....而堆就比较厉害了,堆负责动态内存分配。什么是动态内存呢?大部分的变量,在编译后就已经确定了自己在内存的位置;而有些变量则是在程序运行过...
  • C++动态内存分配详解(new/new[]和delete/delete[])

    万次阅读 多人点赞 2018-09-07 13:14:42
    一、为什么需要动态内存分配? 在C++程序中,所有内存需求都是在程序执行之前通过定义所需的变量来确定的。...1.C++中通过new关键字进行动态内存申请 2.C++中的动态内存分配是基于类型进行的 ...
  • C/C++动态分配内存

    千次阅读 多人点赞 2018-04-05 13:41:36
    https://blog.csdn.net/Errors_In_Life/article/details/78889951https://blog.csdn.net/a573233077/article/details/50518909https://blog.csdn.net/weiwenhp/article/details/80065871.  需要动态分配...
  • c/c++动态内存申请与释放

    千次阅读 2018-08-09 09:43:59
    1,C中内存申请有哪些(标准库函数) 函数名 函数原型 ... 动态内存的申请 函数本身不知内存类型,关心内存的总字节数 int * p =(int *)malloc(sizeof(int)* length); ...
  • c++:为什么要使用动态内存分配

    千次阅读 多人点赞 2018-08-29 14:59:45
    // 方式二:动态内存分配法 A * a = new A(); 两者有什么差别呢? 实际上,方式二即等价于如下代码: A * a = new A(); 等价于 A * a; a = new A(); 方式一就是直接将a放入栈区(局部变量,大小受限,自动...
  • C++ Code:动态分配数组内存的六种方法

    万次阅读 多人点赞 2017-12-25 10:30:36
    问题:  如何快速给数组分配自定义长度的... 提到动态分配C++的数组,我们想到的标签会有:malloc-free、new-delete、一维、二维...等等,本博客初创初心是各大公司企业都会青睐于在笔试或者面试中,要求应届生具备
  • C++---之动态内存申请new

    千次阅读 2019-06-26 17:07:31
    一、为什么需要动态内存分配? 在C++程序中,所有内存需求都是在程序执行之前通过定义所需的变量来确定的。...1.C++中通过new关键字进行动态内存申请 2.C++中的动态内存分配是基于类型进行的 3.del...
  • 学习C++动态内存的管理之前,我们先回顾一下C语言的动态内存管理,这是我写的一片关于C语言的动态内存管理博客:https://blog.csdn.net/porryCn/article/details/80280708。 简单的回顾:     C语言使用 ...
  • C++ new 动态内存 对象初始化

    千次阅读 2018-08-21 16:40:57
    User a[2]=User(23,24);这种写法对数组的每一个对象调用有参数的构造函数,是功能实现最完备的形式。 User a(23,24);这种写法可以调用有参数的构造函数。...这种写法不初始化,仅分配内存,里面是乱码。 int a=...
  • C++之new动态分配内存生成数组

    万次阅读 2018-05-16 12:27:14
    (2) 在main中使用new操作符分配内存生成动态数组,实现数组的输入和输出,函数结束时使用delete回收动态分配的内存空间。 (3) 通过Debug跟踪指针的值及其所指的对象的值。 #include using namespace std; ...
  • C++内存泄漏检测工具

    2017-09-14 09:44:28
    一个非常好用的C++内存泄漏检测工具以及使用例子,可以方便地检测出开发的程序中内存泄漏情况,程序员必备工具之一。
  • C++共享内存进程间通信 FileMapping用于进程间快速通信
  • c++动态内存

    千次阅读 2018-02-09 11:01:36
    C++ 动态内存了解动态内存在 C++ 中是如何工作的是成为一名合格的 C++ 程序员必不可少的。C++ 程序中的内存分为两个部分:栈:在函数内部声明的所有变量都将占用栈内存。堆:这是程序中未使用的内存,在程序运行时...
  • 内存的静态分配和动态分配的区别主要是两个:  一是时间不同。静态分配发生在程序编译和连接的时候。动态分配则发生在程序调入和执行的时候。  二是空间不同。堆都是动态分配的,没有静态分配的堆。栈有2种...
  • C++中为数组动态分配内存

    千次阅读 2015-06-02 18:14:00
    C++中为数组动态分配内存的格式如下:   第一步:声明  type (p)[常量1][常量2]...[常量n]; 第二步:申请  p=new type[x][常量1][常量2]...[常量n]; 说明:先定义一个n维的数组指针,其中p是一个指针...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 796,174
精华内容 318,469
关键字:

c++动态内存

c++ 订阅
友情链接: v3n1_4.rar