C++动态内存管理

最新推荐文章于 2024-04-27 16:49:54 发布
最新推荐文章于 2024-04-27 16:49:54 发布
阅读量1.1k 收藏 16
点赞数 25
分类专栏： C++基础知识 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73281594/article/details/137024772
版权

目录

C/C++内存分配

C++内存管理

C++内存管理介绍

C++内存管理使用

C++内存管理基本语法

operator new 和 operator delete函数

定位new表达式(placement-new)

基本语法

使用场景

malloc/free和new/delete

相同点

不同点

C/C++内存分配

在C语言动态内存管理章节已经了解到内存的分类，包括下面四个区域：

  1. 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。
  2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。
  3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
  4. 数据段--存储全局数据和静态数据。
  5. 代码段--可执行的代码/只读常量
int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
    static int staticVar = 1;
    int localVar = 1;
    int num1[10] = { 1, 2, 3, 4 };
    char char2[] = "abcd";
    const char* pChar3 = "abcd";
    int* ptr1 = (int*)malloc(sizeof(int) * 4);
    int* ptr2 = (int*)calloc(4, sizeof(int));
    int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
    free(ptr1);
    free(ptr3);
}

在上面代码中，globalVar为全局变量，与静态变量staticGlobalVar和staticGlobalVar，存放在数据段（静态区），num1和char2均为局部数组，所以均放在内存的栈区。对于指针类型pChar3，ptr1，ptr2和ptr3均为局部变量，所以均存放在栈区，但是pChar3指向的内容是字符串的第一个元素的地址，该地址在内存的代码段（常量区），其余三个指针均指向在内存堆区开辟的空间

📌

注意尽管char2中存储的是字符串，但是该字符串只是存放在代码段区域的字符串的拷贝，所以依旧在栈区

C++内存管理

C++内存管理介绍

在C语言中，使用malloc/calloc/realloc进行动态内存空间的开辟，但是这三种方式中只有calloc会对数据区域进行初始化，并且初始化值为0，并且使用free宏对动态分配的空间进行释放

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

int main()
{
    int* ptr = (int*)malloc(sizeof(int) * 2);
    assert(ptr);
    int* ptr1 = (int*)calloc(2, sizeof(int));
    assert(ptr1);
    int* tmp = (int*)realloc(ptr, sizeof(int) * 20);
    assert(tmp);
    //此处不需要释放ptr原来指向的空间
    ptr = tmp;
    free(ptr);
    free(ptr1);

    return 0;
}

在C++中，仍然可以使用malloc/calloc/realloc进行动态内存分配和free进行空间释放，但是更推荐使用new进行动态内存分配以及delete进行空间释放，所以上面的代码可以转化为下面的代码

#include <iostream>
using namespace std;

int main()
{
    int* ptr = new int[2];
    int* ptr1 = new int[2] {0};

    delete[] ptr;
    delete[] ptr1;

    return 0;
}

C++内存管理使用

C++内存管理基本语法

在C++中，使用new关键字进行内存空间的申请

//单个空间开辟
指定类型的指针 = new 需要开辟的空间中的数据类型;
指定类型的指针 = new 需要开辟的空间中的数据类型(初始值);
//连续空间开辟
指定类型的指针 = new 需要开辟的空间中的数据类型[需要开辟的空间个数];
指定类型的指针 = new 需要开辟的空间中的数据类型[需要开辟的空间个数]{每一个空间初始化值};

在C++中，使用delete关键字进行内存空间的释放

//单个空间释放
delete 指向需要释放的空间的指针;
//连续空间释放
delete[] 指向需要释放的空间的指针;

📌

注意，new和delete一定要匹配使用，单个空间开辟就使用单个空间的释放，连续空间的开辟就使用连续空间的释放，更不能new和free等交叉使用

对于内置类型来说，如下面代码

#include <iostream>
using namespace std;

int main()
{
    //单个空间开辟和释放
    int* ptr = new int;//不初始化
    cout << *ptr << endl;
    int* ptr1 = new int(10);//初始化为10
    cout << *ptr1 << endl;
    delete ptr;
    delete ptr1;

    //连续空间开辟和释放
    int* ptr2 = new int[5];//不初始化
    int* ptr3 = new int[5] {1, 2, 3, 4, 5};//初始化
    for (int i = 0; i < 5; i++)
    {
        cout << ptr2[2] << " ";
    }
    cout << endl;
    for (int i = 0; i < 5; i++)
    {
        cout << ptr3[i] << " ";
    }

    delete[] ptr2;
    delete[] ptr3;

    return 0;
}
输出结果：
-842150451
10
-842150451 -842150451 -842150451 -842150451 -842150451
1 2 3 4 5

对于内置类型来说，如果使用free进行释放时，并不会出现报错

#include <iostream>
using namespace std;

int main()
{
    //单个空间开辟和释放
    int* ptr = new int;//不初始化
    cout << *ptr << endl;
    int* ptr1 = new int(10);//初始化为10
    cout << *ptr1 << endl;
    free(ptr);
    free(ptr1);

    //连续空间开辟和释放
    int* ptr2 = new int[5];//不初始化
    int* ptr3 = new int[5] {1, 2, 3, 4, 5};//初始化
    for (int i = 0; i < 5; i++)
    {
        cout << ptr2[2] << " ";
    }
    cout << endl;
    for (int i = 0; i < 5; i++)
    {
        cout << ptr3[i] << " ";
    }

    free(ptr2);
    free(ptr3);

    return 0;
}
输出结果：
-842150451
10
-842150451 -842150451 -842150451 -842150451 -842150451
1 2 3 4 5

尽管也正常输出，但是依旧不建议使用free对new开辟的空间进行释放

对于自定义类型来说，分两种情况：

  1. 自定义类型中的成员变量仅为内置类型
  2. 自定义类型中的成员变量有指针指向的动态内存分配的空间
#include <iostream>
using namespace std;

//成员变量仅为内置类型
class test
{
private:
    int _num;
public:
    test(int num = 1)
        :_num(num)
    {
        cout << "test()" << endl;
    }
    ~test()
    {
        cout << "~test()" << endl;
    }
};

int main()
{
    test* ptr = new test;
    cout << endl;
    test* ptr1 = new test(2);
    cout << endl;
    test* ptr2 = new test[5]{ 1,2,3,4,5 };
    cout << endl;
    delete ptr;
    cout << endl;
    delete ptr1;
    cout << endl;
    delete[] ptr2;

    return 0;
}
输出结果：
test()

test()

test()
test()
test()
test()
test()

~test()

~test()

~test()
~test()
~test()
~test()
~test()

在上面的代码中，对于单个对象空间的分配时，会调用一次构造函数，而对连续空间的对象空间分配时，会调用对象个数次构造函数。对于空间释放，当只有一个对象时，只调用一次析构函数，当有连续空间的对象时，则会调用对象个数次析构函数

如果将上面代码中的delete改为free，则不会调用析构函数

#include <iostream>
using namespace std;

//成员变量仅为内置类型
class test
{
private:
    int _num;
public:
    test(int num = 1)
        :_num(num)
    {
        cout << "test()" << endl;
    }
    //~test()
    //{
    //    cout << "~test()" << endl;
    //}
};

int main()
{
    test* ptr = new test;
    cout << endl;
    test* ptr1 = new test(2);
    cout << endl;
    test* ptr2 = new test[5]{ 1,2,3,4,5 };
    cout << endl;
    free(ptr);
    cout << endl;
    free(ptr1);
    cout << endl;
    free(ptr2);

    return 0;
}
输出结果：
test()

test()

test()
test()
test()
test()
test()
但是此时编译器会报警告：
“ptr”使用“new”分配，但使用“free”删除
“ptr2”使用“new []”分配，但使用“free”删除
“ptr1”使用“new”分配，但使用“free”删除

在上面的代码中，使用new为自定义类型的对象开辟空间时会调用构造函数，但是释放空间时使用free编译器会给出警告，如果没有删除析构函数，那么程序将运行终止，所以不要使用free和delete交叉使用

另外对于下面的代码来说

#include <iostream>
using namespace std;

//成员变量仅为内置类型
class test
{
private:
    int _num;
public:
    test(int num = 1)
        :_num(num)
    {
        cout << "test()" << endl;
    }
    ~test()
    {
        cout << "~test()" << endl;
    }
};

int main()
{
    test* ptr = new test;
    cout << endl;
    test* ptr1 = new test(2);
    cout << endl;
    test* ptr2 = new test[5]{ 1,2,3,4,5 };
    cout << endl;
    delete ptr;
    cout << endl;
    delete ptr1;
    cout << endl;
    delete ptr2;

    return 0;
}

因为ptr2指向的空间是连续的对象空间，此时使用对单个空间释放形式的delete时，程序也会终止运行，所以单个空间开辟使用单个空间释放，多个空间开辟使用多个空间释放

#include <iostream>
using namespace std;

//对应有资源申请的内置类型来说
class test
{
private:
    int* _a;
public:
    test()
        :_a(nullptr)
    {
        _a = new int[5];
        cout << "test()" << endl;
    }

    ~test()
    {
        delete[] _a;
        cout << "~test()" << endl;
    }

};

int main()
{
    //单个空间开辟和释放
    test* ptr = new test;
    cout << endl;
    delete ptr;
    cout << endl;

    //多个空间开辟和释放
    test* ptr1 = new test[5];
    cout << endl;
    delete[] ptr1;
    cout << endl;

    return 0;
}
输出结果：
test()

~test()

test()
test()
test()
test()
test()

~test()
~test()
~test()
~test()
~test()

在上面的代码中，类成员变量的类型为指针类型，在构造函数中，为该指针分配了5个连续的int类型空间，在析构函数中，释放这5个连续的空间。当类实例化对象时，对于单个空间的开辟和释放会调用一次构造函数和一次析构函数，而对于连续空间的开辟和释放会调用连续空间个数次的构造函数和析构函数

#include <iostream>
using namespace std;

//对应有资源申请的内置类型来说
class test
{
private:
    int* _a;
public:
    test()
        :_a(nullptr)
    {
        _a = new int[5];
        cout << "test()" << endl;
    }

    ~test()
    {
        delete[] _a;
        cout << "~test()" << endl;
    }

};

int main()
{
    //单个空间开辟和释放
    test* ptr = new test;
    cout << endl;
    free(ptr);
    cout << endl;

    return 0;
}

对于单个空间的释放来说，不会出现程序崩溃，尽管没有调用析构函数释放类对象成员变量指向的内存空间，但是当程序结束时，该空间会得到释放，此时也即内存泄漏

#include <iostream>
using namespace std;

//对应有资源申请的内置类型来说
class test
{
private:
    int* _a;
public:
    test()
        :_a(nullptr)
    {
        _a = new int[5];
        cout << "test()" << endl;
    }

    ~test()
    {
        delete[] _a;
        cout << "~test()" << endl;
    }

};

int main()
{
    //多个空间开辟和释放
    test* ptr1 = new test[5];
    cout << endl;
    free(ptr1);
    cout << endl;

    return 0;
}

对于多个连续空间的释放来说，因为free只能释放一个空间，如果直接理解会认为释放掉了连续空间中的第一个空间而并未释放后面的空间导致程序内存泄漏错误。但是实际上并不是，因为内存泄漏只有在没有足够内存时才会导致程序崩溃，编译器是不会检查内存泄露的。而真正导致程序崩溃的原因是VS在此处做出的优化

而之所以free释放空间时会报错，就是因为返回的起始位置并不是开辟的空间的真正起始位置从而导致程序崩溃，free释放空间时必须从开辟的空间的实际起始位置开始，而不能释放部分空间，而delete（不是delete[]）的底层设计也是free（只是做了一些异常检查），所以调用delete而不是delete[]也会导致程序崩溃，而delete[]不崩溃是因为在释放连续空间时会先向前移动找到存储空间个数的值，再通过该值确定调用析构函数的次数，最后销毁指向连续空间的指针

总结：

对于内置类型来说，因为内置类型开辟的空间如果使用free也是直接释放指针指向的空间，只是不会调用析构函数，一般情况下不会出现问题，但是不推荐使用free。建议对单个空间用delete，连续空间用delete[]

对于自定义类型来说，使用free比较容易产生内存泄漏，所以不论是成员变量是内置类型，还是成员变量是涉及资源申请的，都建议使用delete和delete[]

operator new 和 operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间

operator new 实际也是通过malloc来申请空间，operator delete 最终是通过free来释放空间的

📌

注意operator new 和 operator delete函数不是运算符重载

内置类型：

对于operator new函数来说

如果是单个空间，那么在申请空间时使用new，底层会调用malloc函数开辟单个空间，但是不同于malloc函数，operator new如果空间申请失败会抛出异常，而不是返回空指针

如果是连续空间，则在申请空间时new[]，底层会调用malloc函数开辟连续的空间

对于operator delete函数来说

如果是单个空间，那么在释放空间时使用delete，底层会调用free函数释放单个空间，但是不同于free宏，operator delete会在释放时检查一些可能存在的问题

如果是连续空间，则在申请空间时delete[]，底层会调用free函数开辟连续的空间

自定义类型：

对于operator new函数来说

如果是单个空间，则在申请空间时使用new，会调用operator new申请空间，再在申请的空间上调用构造函数创建对象

如果是多个连续空间，则在申请空间时使用new[]，会调用operator new申请连续的空间，再在申请的连续空间上调用申请空间个数次的构造函数创建对象

对于operator delete函数来说

如果是单个空间，则在释放空间时使用delete，释放空间时先调用类的析构函数，再调用operator delete函数释放指向单个存储对象空间的指针

如果是连续空间，则在释放空间时使用delete[]，释放空间时先调用类的析构函数，调用次数为创建的对象的个数，最后调用operator delete函数释放指向存储对象的连续空间的指针

定位new表达式(placement-new)

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象

基本语法

new (开辟空间的起始地址) 类型或者new (开辟空间的起始地址) 类型(初始值)

使用场景

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显式调构造函数进行初始化

#include <iostream>
using namespace std;

class A
{
public:
    A(int a = 0)
        : _a(a)
    {
        cout << "A():" << this << endl;
    }
    ~A()
    {
        cout << "~A():" << this << endl;
    }
private:
    int _a;
};

int main()
{
    // p1现在指向的只不过是A类大小的一段空间，还不能算是一个对象，因为构造函数没有执行
    A* p1 = (A*)malloc(sizeof(A));
    // 在空间中调用构造函数创建对象
    new(p1)A;  // 注意：如果A类的构造函数有参数时，此处需要传参
    p1->~A();// 析构函数可以显式调用
    free(p1);
    A* p2 = (A*)operator new(sizeof(A));// 也可以直接使用operator new函数开辟空间
    // 在空间中调用构造函数创建对象
    new(p2)A(10);
    p2->~A();
    delete p2;
    return 0;
}

malloc/free和new/delete

相同点

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放

不同点

  1. malloc和free是函数，new和delete是操作符
  2. malloc申请的空间不会初始化，new可以初始化
  3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可， 如果是多个对象，[]中指定对象个数即可
  4. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
  5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
  6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理
怡晗★
关注
  • 25
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++内存管理机制笔记
04-13
C++内存管理机制笔记
侯捷C++内存管理
09-02
侯捷C++内存管理的百度云的链接与密码。永久有效
基于 c++实现 内存管理 - 动态分区分配方式模拟 代码详解教程
01-12
功能描述 - 在模拟过程中，如果所访问指令在内存中，则显示其物理地址，并转到下一条指令；如果没有在内存中，则发生缺页，此时需要记录缺页次数，并将其调入内存。如果4个内存块中已装入作业，则需进行页面置换。 - 所有320条指令执行完成后，计算并显示作业执行过程中发生的缺页率。 - 置换算法可以选用FIFO或者LRU算法 - 作业中指令访问次序可以按照下面原则形成： 50%的指令是顺序执行的，25%是均匀分布在前地址部分，25％是均匀分布在后地址部分 基本任务 假设每个页面可存放10条指令，分配给一个作业的内存块为4。模拟一个作业的执行过程，该作业有320条指令，即它的地址空间为32页，目前所有页还没有调入内存。 功能描述 在模拟过程中，如果所访问指令在内存中，则显示其物理地址，并转到下一条指令；如果没有在内存中，则发生缺页，此时需要记录缺页次数，并将其调入内存。如果4个内存块中已装入作业，则需进行页面置换。 所有320条指令执行完成后，计算并显示作业执行过程中发生的缺页率。 置换算法可以选用FIFO或者LRU算法 作业中指令访问次序可以按照下面原则形成：
C++内存管理技术内幕
08-25
C++内存管理技术内幕 pdf
C++内存管理
07-14
内存管理是C++最令人切齿痛恨的问题，也是C++最有争议的问题，C++高手从中获得了更好的性能，更大的自由，C++菜鸟的收获则是一遍一遍的检查代码和对C++的痛恨，但内存管理在C++中无处不在，内存泄漏几乎在每个C++程序中都会发生，因此要想成为C++高手，内存管理一关是必须要过的，除非放弃C++，转到Java或者.NET，他们的内存管理基本是自动的，当然你也放弃了自由和对内存的支配权，还放弃了C++超绝的性能。本期专题将从内存管理、内存泄漏、内存回收这三个方面来探讨C++内存管理问题。
深入详解C/C++动态内存管理
热门推荐
dvlinker的技术专栏
07-19 1万+
本文详细讲述了C/C++动态内存管理方面的内容，并具体阐述了几类常见的动态内存异常，以供大家借鉴或参考！
C/C++：动态内存管理
weixin_43908419的博客
03-04 2265
本文对C/C++动态内存管理进行了详解。第一章首先介绍了C/C++程序的内存分布情况，第二章介绍了C/C++动态内存管理相关的操作符和函数，最后一章介绍了内存泄漏。
【带你吃透C++】C++动态内存管理
平淡中造就不平凡
01-21 5988
作为一名编程初学者，通常学习中，发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状，时隐时现，增加了改错的难度。 了解内存分配并掌握运用它是必不可少的。本文主要针对C++动态内存管理内容进行分享，如果想了解C语言动态内存管理可以参考：【C语言进阶】动态内存管理（详细介绍）
c/c++动态内存管理
wzd547191555的博客
03-16 1989
准备 提示：写完文章后，目录可以自动生成 文章目录准备前言一、c/c++内存分布二、c语言中动态内存管理的方式1.2.3、c++内存管理方式4、new和delete实现原理总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、c/c++内存分布 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的
C++教学——从入门到精通 10.循环
QIPABOSHI的博客
04-24 362
一些事嘛，需要重复做，这就是循环在开始学之前我提一个事，最好先学Python再学C++，不然就会像我和piaojunhe_0825一样有C++后遗症，在Python里写了一个for(int i=0;i
C++ WebServer的细节理解
我的博客
04-22 617
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
笨蛋学C++【C++基础第六弹】
YSL_Monet的博客
04-24 809
定义类需要用到关键字 class，然后指定类的名称，类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数class 类名{访问修饰符（public/protected/private）:成员变量;成员函数();
C 练习实例36 - 求100之内的素数
最新发布
2401_82561004的博客
04-27 884
质数（prime number）又称素数，有无限个。一个大于1的自然数，除了1和它本身外，不能被其他自然数整除。// Copyright © 2013年 编程字典. All rights reserved.求100之内的素数。
C++——初识模板
qq_74245477的博客
04-22 905
之前实现的数据结构，比如栈，我们为了便于修改存储的数据类型，通常使用typedef来重定义数据类型，但是这样有一个缺陷，会导致我们定义的栈存储的都是一种数据，如果同时需要两个栈，一个存储int，一个存储自定义类型，那么typedef就不管用了。比如：当用int类型使用函数模板时，编译器通过对实参类型的推演，将T确定为int类型，然后产生一份专门处理int类型的代码，对于字符类型也是如此。概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型的版本。
理解C语言中的位操作和整数类型：一个温度传感器读取问题的解析
qq_61637982的博客
04-24 233
当我们编写嵌入式系统的代码时，我们经常需要使用位操作来处理硬件设备的数据。然而，如果我们对C语言的位操作和整数类型不完全理解，可能会遇到一些难以理解的问题。在这篇博客中，我将通过一个实际的例子来解释这些概念，并提供一个解决方案。
C++中的抽象类
hh121386的博客
04-23 199
C++中的抽象类
LeetCode //C - 18. 4Sum
Made in Code
04-22 709
【代码】LeetCode //C - 18. 4Sum。
掉落回弹问题（C语言）
m0_67184754的博客
04-22 363
【代码】掉落回弹问题（C语言）
CSAPP | Lab2-Bomb Lab详细解析
wangs29的博客
04-24 1254
邪恶的邪恶博士在我们班的机器上安放了大量的“二元炸弹”。二进制炸弹是一个由一系列阶段组成的程序。每个阶段都要求你在 stdin 上键入一个特定的字符串。如果你键入了正确的字符串，那么这个阶段就会被拆除，炸弹就会进入下一个阶段。否则，炸弹会通过打印“ BOOM 然后终止。当每个阶段都被拆除时，炸弹就会被拆除。我们要处理的炸弹太多了，所以我们给每个学生一个炸弹去拆除。你们的任务，你们别无选择，只能接受，就是在due date前拆除炸弹。祝你好运，欢迎加入拆弹小组！
c++ 动态内存管理类
03-28
C++中的动态内存管理类主要是指智能指针类，它们用于管理动态分配的内存，可以自动释放内存，避免内存泄漏和悬空指针的问题。C++标准库提供了两种主要的智能指针类：shared_ptr和unique_ptr。 1. shared_ptr：shared_ptr是一种共享所有权的智能指针，可以被多个shared_ptr对象共同拥有。它使用引用计数的方式来管理内存，当最后一个shared_ptr对象销毁时，会自动释放内存。使用shared_ptr可以避免手动释放内存和悬空指针的问题。 2. unique_ptr：unique_ptr是一种独占所有权的智能指针，同一时间只能有一个unique_ptr对象拥有某块内存。它使用移动语义来实现所有权的转移，当unique_ptr对象销毁时，会自动释放内存。使用unique_ptr可以避免内存泄漏和悬空指针的问题。 这些智能指针类都定义在<memory>头文件中，使用时需要包含该头文件。它们提供了类似于原始指针的操作符重载，可以通过*和->来访问所指向对象的成员。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

怡晗★

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值