72-动态内存申请的结果

最新推荐文章于 2022-04-21 11:18:32 发布
最新推荐文章于 2022-04-21 11:18:32 发布
阅读量189 收藏
点赞数
分类专栏： # C++基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/piaoguo60/article/details/108730224
版权

注：博客中内容主要来自《狄泰软件学院》，博客仅当私人笔记使用。

测试环境：Ubuntu 10.10

GCC版本：9.2.0

 

一、动态内存申请的结果

1）问题

                    动态内存申请一定成功吗？

 

2）常见的动态内存分配代码

C代码：

int* p = (int*)malloc(10*sizeof(int));    //(int*)malloc为强转，默认void*

if( p != NULL)
{
    // ... ...
}

C++代码：

int* p = new int[10];    //如果这里new失败，会抛出异常，终止程序。

if( p != NULL)
{
    // ... ...
}

3）必须知道的事实！

    -    malloc函数申请失败时返回NULL值

    -    new关键字申请失败时(根据编译器的不同)

        *返回NULL值

        *抛出std::bad_alloc异常(g++编译器会抛出异常)

 

4）问题

            new语句中的异常是怎么抛出来的？

 

5）new关键字在C++规范中的标准行为

    -    在堆空间申请足够大的内存

        *成功：

                在获取的空间中调用构造函数创建对象，返回对象的地址

        *失败：

                抛出std::bad_alloc异常

 

6）new关键字在C++规范中的标准行为

        -    new在分配内存时

                *如果空间不足，会调用全局的new_handler()函数

                *new_handler()函数中抛出std::bad_alloc异常

        -    可以自定义new_handler()函数

                *处理默认的new内存分配失败的情况

 

7）new_handler()的定义和使用

通过set_new_handler() 设置自定义的函数，处理内存不足情况，处理堆空间不足的情况。

一般在my_new_handler进行内存整理，空出更多堆空间；终止程序exit(1)；抛出异常，异常处理，这种比较友好。

 

8）问题

                    如何跨编译器统一new的行为，提高代码移植性？

                    new/delete或者new[]/delete[]的重载

9）解决方案

        -    全局范围(不推荐)

                *重新定义new/delete的实现，不抛出任何异常

                *自定义new_handler()函数，不抛出任何异常

        -    类层次范围

                *重载new/delete，不抛出任何异常

        -    单次动态内存分配

                *使用nothrow参数，指明new不抛出异常

 

编程实验
动态内存申请
E3-1.cpp
#include <iostream>
#include <new>
#include <cstdlib>
#include <exception>


using namespace std;


class Test
{
    int m_value;
public:
    Test()
    {
        cout << "Test()" << endl;
        
        m_value = 0;
    }
    
    ~Test()
    {
        cout << "~Test()" << endl;  
    }
    
    void* operator new (unsigned int size)    //异常规格说明
    {
        cout << "operator new: " << size << endl;
        
        //return malloc(size);    //注释为了模拟，内存分配失败
    
        return NULL;
    }
    
    void operator delete (void* p)
    {
        cout << "operator delete: " << p << endl;
        
        free(p);
    }
    
    void* operator new[] (unsigned int size) throw()  //异常规格说明
    {
        cout << "operator new[]: " << size << endl;
        
        //return malloc(size);    //注释为了模拟，内存分配失败

        return NULL;
    }
    
    void operator delete[] (void* p)
    {
        cout << "operator delete[]: " << p << endl;
        
        free(p);
    }
};


void my_new_handler()
{
    cout << "void my_new_handler()" << endl;
}


void ex_func_1()
{
    //new_handler是预定义函数指针，指向了没有返回值和没有参数的函数。
    new_handler func = set_new_handler(my_new_handler);
    
    try
    {
        cout << "func = " << func << endl;
        
        if( func )    //默认情况，可能没有处理函数，func为空
        {
            func();
        }
    }
    catch(const bad_alloc&)
    {
        cout << "catch(const bad_alloc&)" << endl;
    }
}


void ex_func_2()
{
    Test* pt = new Test();
    
    cout << "pt = " << pt << endl;
    
    delete pt;
}


void ex_func_3()
{
    int* p = new(nothrow) int[10];    //不管结果有没有成功，都不抛出异常nothrow
                                     //失败返回为空就行了
    // ... ...
    
    delete[] p; 
    
    int bb[2] = {0};
    
    struct ST
    {
        int x;
        int y;
    };        //8字节
    
    ST* pt = new(bb) ST();    //ST()在bb位置(指定地址)创建对象
    
    pt->x = 1;
    pt->y = 2;
    
    cout << bb[0] << endl;    //证明对象在bb位置创建对象，因此bb[0] = 1
    cout << bb[1] << endl;    //同上，bb[1] = 2
    
    pt->~ST();        //手动调用析构函数
}


int main(int argc, char *argv[])
{
    // ex_func_1();
    // ex_func_2();
    // ex_func_3();
    
    return 0;
}

操作：

1）只使用ex_func_1()函数：

g++编译器：编译成功。运行结果：

func = 0

没有全局new_handler指针。

vs2010编译：编译成功，运行结果：

func = 00000000

没有全局new_handler指针。

bcc编译：编译成功，运行结果：

func = 00401474
catch<const bad_alloc&>

分析：new失败不同编译器行为不一样。

 

2）只使用ex_func_2()函数：

g++编译器：编译有警告，运行结果：

operator new: 4
Test()
段错误(因为new的时候没有内存分配，构造函数却在这个地址进行赋值操作，产生段错误)

分析：调用了构造函数。

vs2010编译器：编译正常，运行结果：

operator new: 4
pt = 00000000

分析：没有调用构造函数。

bcc编译器：编译正常，运行结果：

operator new: 4
pt = 00000000

分析：没有调用构造函数。

 

为了同意程序一致性：给new添加异常规格声明

#include <iostream>
#include <new>
#include <cstdlib>
#include <exception>


using namespace std;


class Test
{
    int m_value;
public:
    Test()
    {
        cout << "Test()" << endl;
        
        m_value = 0;
    }
    
    ~Test()
    {
        cout << "~Test()" << endl;  
    }
    
    void* operator new (unsigned int size) throw()    //异常规格说明
    {
        cout << "operator new: " << size << endl;
        
        //return malloc(size);    //注释为了模拟，内存分配失败
    
        return NULL;
    }
    
    void operator delete (void* p)
    {
        cout << "operator delete: " << p << endl;
        
        free(p);
    }
    
    void* operator new[] (unsigned int size) throw()  //异常规格说明
    {
        cout << "operator new[]: " << size << endl;
        
        //return malloc(size);    //注释为了模拟，内存分配失败

        return NULL;
    }
    
    void operator delete[] (void* p)
    {
        cout << "operator delete[]: " << p << endl;
        
        free(p);
    }
};


void my_new_handler()
{
    cout << "void my_new_handler()" << endl;
}


void ex_func_1()
{
    //new_handler是预定义函数指针，指向了没有返回值和没有参数的函数。
    new_handler func = set_new_handler(my_new_handler);
    
    try
    {
        cout << "func = " << func << endl;
        
        if( func )    //默认情况，可能没有处理函数，func为空
        {
            func();
        }
    }
    catch(const bad_alloc&)
    {
        cout << "catch(const bad_alloc&)" << endl;
    }
}


void ex_func_2()
{
    Test* pt = new Test();
    
    cout << "pt = " << pt << endl;
    
    delete pt;
    /*
    pt = new Test[5];
    
    cout << "pt = " << pt << endl;
    
    delete[] pt;*/ 
}


void ex_func_3()
{
    int* p = new(nothrow) int[10];    //不管结果有没有成功，都不抛出异常nothrow
                                     //失败返回为空就行了
    // ... ...
    
    delete[] p; 
    
    int bb[2] = {0};
    
    struct ST
    {
        int x;
        int y;
    };        //8字节
    
    ST* pt = new(bb) ST();    //ST()在bb位置(指定地址)创建对象
    
    pt->x = 1;
    pt->y = 2;
    
    cout << bb[0] << endl;    //证明对象在bb位置创建对象，因此bb[0] = 1
    cout << bb[1] << endl;    //同上，bb[1] = 2
    
    pt->~ST();        //手动调用析构函数
}


int main(int argc, char *argv[])
{
    // ex_func_1();
    ex_func_2();
    // ex_func_3();
    
    return 0;
}

g++编译器：编译正常，运行结果：

operator new: 4
pt = 0

 

测试new[]：

#include <iostream>
#include <new>
#include <cstdlib>
#include <exception>


using namespace std;


class Test
{
    int m_value;
public:
    Test()
    {
        cout << "Test()" << endl;
        
        m_value = 0;
    }
    
    ~Test()
    {
        cout << "~Test()" << endl;  
    }
    
    void* operator new (unsigned int size) throw()    //异常规格说明
    {
        cout << "operator new: " << size << endl;
        
        //return malloc(size);    //注释为了模拟，内存分配失败
    
        return NULL;
    }
    
    void operator delete (void* p)
    {
        cout << "operator delete: " << p << endl;
        
        free(p);
    }
    
    void* operator new[] (unsigned int size) throw()  //异常规格说明
    {
        cout << "operator new[]: " << size << endl;
        
        //return malloc(size);    //注释为了模拟，内存分配失败

        return NULL;
    }
    
    void operator delete[] (void* p)
    {
        cout << "operator delete[]: " << p << endl;
        
        free(p);
    }
};


void my_new_handler()
{
    cout << "void my_new_handler()" << endl;
}


void ex_func_1()
{
    //new_handler是预定义函数指针，指向了没有返回值和没有参数的函数。
    new_handler func = set_new_handler(my_new_handler);
    
    try
    {
        cout << "func = " << func << endl;
        
        if( func )    //默认情况，可能没有处理函数，func为空
        {
            func();
        }
    }
    catch(const bad_alloc&)
    {
        cout << "catch(const bad_alloc&)" << endl;
    }
}


void ex_func_2()
{
    Test* pt = new Test();
    
    cout << "pt = " << pt << endl;
    
    delete pt;

    pt = new Test[5];
    
    cout << "pt = " << pt << endl;
    
    delete[] pt; 
}


void ex_func_3()
{
    int* p = new(nothrow) int[10];    //不管结果有没有成功，都不抛出异常nothrow
                                     //失败返回为空就行了
    // ... ...
    
    delete[] p; 
    
    int bb[2] = {0};
    
    struct ST
    {
        int x;
        int y;
    };        //8字节
    
    ST* pt = new(bb) ST();    //ST()在bb位置(指定地址)创建对象
    
    pt->x = 1;
    pt->y = 2;
    
    cout << bb[0] << endl;    //证明对象在bb位置创建对象，因此bb[0] = 1
    cout << bb[1] << endl;    //同上，bb[1] = 2
    
    pt->~ST();        //手动调用析构函数
}


int main(int argc, char *argv[])
{
    // ex_func_1();
    ex_func_2();
    // ex_func_3();
    
    return 0;
}

g++编译器：编译正常，运行结果：

operator new: 4
pt = 0
operator new[]: 24
pt = 0

vs2010编译器(bcc编译器)：编译正常，运行结果：

operator new: 4
pt = 00000000
operator new[]: 24
pt = 00000000

 

3）只使用ec_func_3()：不管结果有没有成功，都不抛出异常nothrow

#include <iostream>
#include <new>
#include <cstdlib>
#include <exception>


using namespace std;


class Test
{
    int m_value;
public:
    Test()
    {
        cout << "Test()" << endl;
        
        m_value = 0;
    }
    
    ~Test()
    {
        cout << "~Test()" << endl;  
    }
    
    void* operator new (unsigned int size) throw()    //异常规格说明
    {
        cout << "operator new: " << size << endl;
        
        //return malloc(size);    //注释为了模拟，内存分配失败
    
        return NULL;
    }
    
    void operator delete (void* p)
    {
        cout << "operator delete: " << p << endl;
        
        free(p);
    }
    
    void* operator new[] (unsigned int size) throw()  //异常规格说明
    {
        cout << "operator new[]: " << size << endl;
        
        //return malloc(size);    //注释为了模拟，内存分配失败

        return NULL;
    }
    
    void operator delete[] (void* p)
    {
        cout << "operator delete[]: " << p << endl;
        
        free(p);
    }
};


void my_new_handler()
{
    cout << "void my_new_handler()" << endl;
}


void ex_func_1()
{
    //new_handler是预定义函数指针，指向了没有返回值和没有参数的函数。
    new_handler func = set_new_handler(my_new_handler);
    
    try
    {
        cout << "func = " << func << endl;
        
        if( func )    //默认情况，可能没有处理函数，func为空
        {
            func();
        }
    }
    catch(const bad_alloc&)
    {
        cout << "catch(const bad_alloc&)" << endl;
    }
}


void ex_func_2()
{
    Test* pt = new Test();
    
    cout << "pt = " << pt << endl;
    
    delete pt;

    pt = new Test[5];
    
    cout << "pt = " << pt << endl;
    
    delete[] pt; 
}


void ex_func_3()
{
    int* p = new(nothrow) int[10];    //不管结果有没有成功，都不抛出异常nothrow
                                     //失败返回为空就行了
    // ... ...
    
    delete[] p; 
    
    int bb[2] = {0};
    
    struct ST
    {
        int x;
        int y;
    };        //8字节
    
    ST* pt = new(bb) ST();    //ST()在bb位置(指定地址)创建对象
    
    pt->x = 1;
    pt->y = 2;
    
    cout << bb[0] << endl;    //证明对象在bb位置创建对象，因此bb[0] = 1
    cout << bb[1] << endl;    //同上，bb[1] = 2
    
    pt->~ST();        //必须手动显示调用析构函数
}


int main(int argc, char *argv[])
{
    // ex_func_1();
    // ex_func_2();
    ex_func_3();
    
    return 0;
}

g++编译器(bcc和vs2010)：编译正常，打印结果：

1
2

 

10）实验结论

        -    不是所有的编译器都遵循C++的标准规范

        -    编译器可能重定义new的实现，并在实现中抛出bad_alloc异常

        -    编译器的默认实现中，可能没有设置全局的new_handler()函数

        -    对于移植性要求较高的代码，需要考虑new的具体细节

 

小结

1）不同的编译器在动态内存分配上的实现细节不同

2）malloc函数在内存申请失败时返回NULL值

3）new关键字在内存申请失败时

        -    可能返回NULL值

        -    可能抛出bad_alloc异常

 

喂你的猴子跑了
关注
专栏目录
RT-Thread快速入门-动态内存堆管理方法
嵌入式技术开发
07-23 272
每种 RTOS 均有内存管理机制，RT-Thread 的内存管理分为两类：动态内存堆管理、内存池管理。本篇文章先来介绍一下相关的内容。
python申请内存函数_python进阶用法2 【从帮助函数看python内存申请机制】
weixin_39978350的博客
01-30 289
前言介绍了四个帮助函数，dir()，help()，type()，id()，通过id()函数进一步分析了python在申请内存方面的效率问题，提到的基本类型有string，list，queue和deque四个帮助函数dir()函数dir()函数是查看函数或模块内的操作方法都有什么，输出的是方法列表。dir('str') 也可以查看自己定义的函数 help()函数help()函数是查看函数或模块用途的...
异常处理、动态内存申请在不同编译器之间...
heima201907的博客
05-05 203
在main() 函数中抛出异常会发生什么 　　由上节中的异常抛出（throw exception）的逻辑分析可知，异常抛出后，会顺着函数调用栈向上传播，在这期间，若异常被捕获，则程序正常运行；若异常在 main() 函数中依然没有被捕获，也就是说在 main() 函数中抛出异常会发生什么呢？（程序崩溃，但因编译器的不同，结果也会略有差异）　　 在 main() 函数中抛出异常 　将上述...
C++ 内存分配(new，operator new)详解
热门推荐
WUDAIJUN的博客
07-09 8万+
讲述C++ new关键字和operator new, placement new之间的种种关联，new的底层实现，以及operator new的重载和一些在内存池，STL中的应用。
NVIDIA-CUDA HPC 编程模型与内存管理初探
tugouxp的专栏
11-12 3178
主存和现存在PCIE框架下可以做到互相访问，路径归纳如下：三种角色，两种存储，六种路径。1.HBM通过BAR透给了HOST，使HOST可以通过MMU给CPU访问，或者通过IOMMU给设备访问。2.相反，Host Memory并没有类似的BAR机制透给 PCIE设备端，PCIE设备端想要访问 HOST MEMORY必须经过 HOST IOMMU的映射一遍，加上PCIE端的SMMU映射，对于PCIE设备端（GPU）来说，要经过两层IOMMU翻译。所以从HOST端和GPU端看起来不太对称。
IOT-OS之RT-Thread（四）--- 时钟管理与内存管理
流云
09-17 1544
操作系统要想协调好各线程的调度管理，离不开时间与空间的管理：时间管理主要靠时钟节拍systick实现，时钟节拍是特定的周期性中断，这个中断可以看做是系统心跳（心跳频率一般设为10-1000HZ，时钟节拍率越快，系统额外开销越大），供系统处理所有和时间有关的事件，如线程的延时、线程的时间片轮转调度以及定时器超时等；空间管理主要是对可用存储空间的管理，一般MCU的存储空间可分为片内RAM与片内FLAS...
内存管理-
qq_44921148的博客
04-21 242
C语言变量的作用域分为：局部变量也叫auto自动变量(auto可写可不写)，一般情况下代码块{}内部定义的变量都是自动变量，它有如下特点： 结果： 静态局部变量 static局部变量的作用域也是在定义的函数内有效。 static局部变量的生命周期和程序运行周期一样，同时staitc局部变量的值只初始化一次，但可以赋值多次。 static局部变量若未赋以初值，则由系统自动赋值：数值型变量自动赋初值0，字符型变量赋空字符。 示例： 结果： 静态全局变量 在函数外定义,作用范围被限制在所定义的文件中。
对于重载new函数所遇到的问题记录
baili123321的博客
11-08 133
出现的问题bad_alloc(); 在这里G++里面没有bad_alloc(const char * _Message)构造函数 #include<iostream> //#include<memory> #include<cstdlib> using namespace std; void *operator new(si...
new的理解
Lemon
08-22 1341
在编码过程中，我们常用new来分配堆内存. MyClass *p = new Myclass; 在这个过程中，实际上经历了3个步骤: 1.调用operator new 分配堆内存;   void *p = operator new(sizeof(MyClass)) 2.调用MyClass的构造函数   MyClass::MyClass(); 3.调用placement new 返回类
c语言二级指针的使用，malloc内存申请
liming0931的专栏
09-05 2259
#include<stdio.h> #include<stdlib.h> void AllocateMemory(int **pGetMemory, int n) { int *p = (int*)malloc(sizeof(int) * n); if (p == NULL) { *pGetMemory = NULL; ...
C++ 异常：std：：bad_alloc, 内存不够了，如何减少代码内存？
qq_40963043的博客
08-12 1万+
对于非嵌入式开发中，空间复杂度相比于时间复杂度确实显得没那么重要，能用数组的都可以尽量避免使用链表，这样减少了代码复杂度，减少了时间复杂度。但是对于一些算法题，对内存有要求的就会出现问题。 正如标题所说的，出现bad_alloc异常，一查就知道原来是内存出现了问题。 我首先想到是会不会是堆栈溢出，但是很快被我否决，因为代码中我并没有使用递归，也最多就三层函数调用。于是我就查看自己定义的变量...
72、动态内存申请的结果
WS857707645的博客
05-14 251
1、动态内存申请一定成功吗？常见的动态内存分配代码：c代码：int *p=（int*）malloc（10*sizeof（int））；            if（p！=NULL）{//...}c++代码：int *p=new int[10];if(p!=NULL) {//...}必须知道的事实：malloc函数申请失败时返回NULL值。new关键字申请失败时（根据编译器的不同），1、返回NULL值...
72-外传篇 3 - 动态内存申请的结果
大家好，我姓郑，就是那个被鲁智深三拳打死的那个屠夫的郑~_~~_~
11-03 250
1、问题1：动态内存申请一定成功吗？2、常见动态内存分配代码3、4、问题2：new语句中的异常怎么跑出来的5、6、7、8、问题 3：如何跨编译器统一new的行为9、解决方案#include <iostream> #include <new> #include <cstdlib> #include <exception>using namespace std;class Test { int
C++学习笔记--new失败后的处理
一念之间、
12-23 3616
众所周知，C++中使用new关键字申请内存成功时会返回申请的内存起始地址，并在该地址上调用构造函数。那么，有考虑过失败的情况吗？ 动态申请的处理方式 C语言 int *p = (int*)malloc(10000000000000000000); if(NULL == p) { //申请失败处理分支 } else { //申请成功处理分支 //..... free(p); } C+...
70-异常处理深度解析
第一大剑豪——索隆
09-22 1689
注：博客中内容主要来自《狄泰软件学院》，博客仅当私人笔记使用。 测试环境：Ubuntu 10.10 GCC版本：9.2.0 一、异常处理深度解析 1）问题 如果在main函数中抛出异常会发生什么？ 2）如果异常不处理，最后会传到哪里？ 3）下面的代码输出什么？ 编程实验 异常的最终处理？ E1-1.cpp #include <iostream> using namespace std; class Test { ...
STM32动态内存管理：无碎片实现
在STM32单片机上实现这种动态内存管理，通常需要编写自定义的mymalloc和myfree函数，这两个函数会根据上述原理进行内存的申请和释放。在提供的代码片段中，可以看到mymalloc函数接收申请的内存大小作为参数，返回...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值