new和delete深度使用研习

最新推荐文章于 2022-05-29 11:30:04 发布
最新推荐文章于 2022-05-29 11:30:04 发布
阅读量350 收藏 1
点赞数 1
分类专栏： C++ 文章标签： c++ 开发语言 new operator new placement new
本文原创作者：-西门吹雪 MMTS_yang
本文链接：https://blog.csdn.net/MMTS_yang/article/details/124688855
版权

使用研习

众所周知

  1. c使用malloc和calloc函数在运行时动态分配内存，并使用free()释放动态分配的内存。c++支持这些函数，并且还有两个运算符new和delete，他们以更好、更简单的方式执行分配和释放内存。
  2. 对于int a、char str[10]等普通变量， 在栈上分配，内存会自动分配和释放。 对于像int *p = new int[10]这样的动态分配内存，程序员有责任在不再需要时释放内存。 如果程序员不释放内存，则会导致 内存泄漏 （直到程序终止时才会释放内存）。
    我们再来看下int *p = new int[10]这段代码的分配过程，个人觉得可以加深理解
    在这里插入图片描述

再分析下如下代码

int *p ;
p = new int[5];

在这里，我们首先声明了一个指针p，然后这个p也被创建在
栈中。new 再堆中分配内存，返回一个指针赋值给p; 下面是内存的结构图

在这里插入图片描述

每个new获取的对象，必须用delete析构并释放内存，以免内存泄漏。

  1. new 运算符请求堆中的内存分配。 如果有足够的内存可用，它将内存初始化为指针变量并返回其地址。
  2. new 运算符的语法：
    pointer_variable = new datatype;
    这里，pointer-variable是data-type类型的指针。数据类型可以是包括数组在内的任何内置数据类型，也可以是包括结构和类在内的任何用户定义的数据类型。
  • 这是初始化内存的语法
    pointer_variable = new datatype(value);
  • 这是分配内存块的语法
    pointer_variable = new datatype[size];

示例：

#include <iostream>
using namespace std;
int main () {
   int *ptr1 = NULL;
   ptr1 = new int;
   float *ptr2 = new float(223.324);
   int *ptr3 = new int[28];
   *ptr1 = 28;
   cout << "指针变量值 1 : " << *ptr1 << endl;
   cout << "指针变量值 2 : " << *ptr2 << endl;
   if (!ptr3)
   		cout << "内存分配失败\n";
   else {
      for (int i = 10; i < 15; i++)
      ptr3[i] = i+1;
      cout << "存储在内存块中的值: ";
      for (int i = 10; i < 15; i++)
      cout << ptr3[i] << " ";
   }
   return 0;
}

输出

指针变量值  1 : 28
指针变量值  2 : 223.324
存储在内存块中的值: 11 12 13 14 15

5. delete运算符

delete 运算符用于释放内存。 用户有权通过此删除运算符释放创建的指针变量。

删除运算符的语法，
delete pointer_variable;
删除已分配内存块的语法，
delete[ ] pointer_variable;

示例：

#include <iostream>
using namespace std;
int main () {
   int *ptr1 = NULL;
   ptr1 = new int;
   float *ptr2 = new float(299.121);
   int *ptr3 = new int[28];
   *ptr1 = 28;
   cout << "指针变量值  1 : " << *ptr1 << endl;
   cout << "指针变量值 2 : " << *ptr2 << endl;
   if (!ptr3)
   cout << "分配失败\n";
   else {
      for (int i = 10; i < 15; i++)
      ptr3[i] = i+1;
      cout << "存储在内存块中的值: ";
      for (int i = 10; i < 15; i++)
      cout << ptr3[i] << " ";
   }
   delete ptr1;
   delete ptr2;
   delete[] ptr3;
   return 0;
}

输出：

指针变量值 1 : 28
指针变量值 2 : 299.121
存储在内存块中的值: 11 12 13 14 15
  1. new 工作机制（分配的过程）：
  • 调用一个名为operator new(或者operator new[])的标准库函数，分配一块足够大的、原始的、未命名的内存空间以便存储特定类型的对象（或对象的数组）
  • 编译器运行相应的构造函数以构造这些对象，并为其传入初始值
  • 对象被分配了空间并构造完成，返回一个指向该对象的指针

下面这段描述new过程的文字引自维基百科：

  • 调用相应的operator new()函数，动态分配内存。如果operator new()不能成功获得内存，则调用new_handler函数。 如果没有设置new_handler函数或者new_handler未能分配足够内存，则抛出std::bad_alloc异常。“new运算符表达式”所调用的operator new()函数，按照C++的名字查找规则，首先做依赖于实参的名字查找（即ADL规则），在要申请内存的数据类型T的内部、数据类型T定义处的名字空间查找；如果没有查找到，则直接调用全局的::operator new()函数。
  • 在分配到的动态内存块上初始化相应类型的对象并返回其首地址。如果调用构造函数初始化对象时抛出异常，则自动调用operator delete()函数释放已经分配到的内存。
  1. delete工作机制（释放过程）
    delete sp;delete[] arr;
  • 调用sp所指对象的或者arr所指数组的元素执行相应的析构函数
  • 调用operator delete 或者operator delete[]标准库函数释放内存空间
    注：删除一个动态分配的内存块后，确保不要再次删除相同的块。防止这种情况发生的一种方法是立即将指针设置为nullptr。删除nullptr无效。
  1. C++ 提供了两种标准来检查分配是否成功：抛出异常；不抛异常返回空。
    第一种：new 失败会抛出std::bad_alloc异常，如果抛出这个异常并且它没有被特定的处理程序处理，那么程序执行就会终止。
    第二种：当内存分配失败时，不抛出一个 bad_alloc异常或终止程序，返回的指针是一个 空指针 ，程序继续正常执行。
  • 抛异常使用
#include <iostream>
#include <new>
 
int main()
{
    try {
        while (true) {
            new int[10000990000ul];
        }
    } catch (const std::bad_alloc& e) {
        std::cout  <<"e.what() -->"<<e.what() << '\n';
    }
}

运行结果

e.what() -->std::bad_alloc

new-handler函数是分配函数在内存分配尝试失败时调用的函数。
默认实现抛出std::bad_alloc。用户可以安装自己的new-handler，它可能提供不同于默认处理程序的行为。
如果new-handler返回，分配函数将重复之前失败的分配尝试，并在分配再次失败时再次调用new-handler。为了结束循环，new-handler可以调用std::set_new_handler(nullptr):如果在分配失败后，分配函数发现std::get_new_handler返回空指针值，它将抛出std::bad_alloc。

#include <iostream>
#include <new>
 
static int i = 0;

void handler(){
    std::cout << "内存申请失败, 程序终止 \n handler 被调次数 "<<i<<std::endl;
    i++;
    if(i>5){
        std::set_new_handler(nullptr);
    }
}
 
int main(){
    std::set_new_handler(handler);
    try {
        while (true) {
            new int[10000990000ul];
        }
    } catch (const std::bad_alloc& e) {
        std::cout  <<"e.what() -->"<<e.what() << '\n';
    }
}

运行结果

内存申请失败, 程序终止 
 handler 被调次数 0
内存申请失败, 程序终止 
 handler 被调次数 1
内存申请失败, 程序终止 
 handler 被调次数 2
内存申请失败, 程序终止 
 handler 被调次数 3
内存申请失败, 程序终止 
 handler 被调次数 4
内存申请失败, 程序终止 
 handler 被调次数 5
e.what() -->std::bad_alloc
  • 不抛异常使用
int *p = new(nothrow) int;
if (!p){
   cout << "内存分配失败\n";
}

struct MyClass {
  int data[100];
  MyClass() {std::cout << "constructed [" << this << "]\n";}
};
MyClass * p2 = new (std::nothrow) MyClass;
if(p2!){
	cout << "内存分配失败\n";
}
  1. new运算符表达式不可重载。但可重载operator new()函数。

new operator

程序运行时可以使用new操作符动态分配(即预留)执行时保存对象或内置数组所需的确切内存量。对象或内置数组是在空闲存储区(也称为堆)中创建的，空闲存储区是分配给每个程序用于存储动态分配的对象的内存区域。一旦内存被分配到空闲存储区中，你就可以通过new返回的指针来访问它。当你不再需要这些内存时，你可以通过使用delete操作符来释放(即释放)这些内存，从而将其返回到自由存储区，这些内存可以被以后的新操作重用。

new操作符,就象sizeof一样是语言内置的。它是可被重载的
在这里插入图片描述

  1. 使用示例1：
//将新创建的double对象初始化为3.14159，并将结果指针赋值给ptr
double *ptr = new double( 3.14159 );
//初始化一个新的Time对象到12:45 PM，并将结果指针赋值给timePtr。
Time *timePtr = new Time( 12, 45, 0 );
//声明了一个int指针gradesArray，并将指向动态分配的10个int数组的第一个元素的指针赋给它.new int[10]值后面的圆括号初始化数组的元素——基本数值类型设为0,bool设为false，指针设为nullptr，类对象由它们的默认构造函数初始化。
int *gradesArray = new int[ 10 ]();
//使用列表初始化器来初始化动态分配的内置数组的元素
int *gradesArray = new int[ 10 ]{};
delete [] gradesArray;
  1. 使用示例2
#include <iostream>
#include <new>
#include <memory>
 
 using namespace std;

class Integer
{
public:
    Integer( int i = 0 ); 
    ~Integer(); 
    void setInteger( int i ); 
    int getInteger() const; 
private:
    int value;
}; 
Integer::Integer( int i ): value( i ){
    cout << "构造 " <<value << endl;
} 
Integer::~Integer(){
    cout << "析构" <<value << endl;
} 
void Integer::setInteger( int i ){
    value = i;
} 

int Integer::getInteger() const{
    return value;
} 
int main()
{
    cout << "创建一个指向Integer的unique_ptr对象\n";
    unique_ptr< Integer > ptrToInteger( new Integer( 7 ) );
    ptrToInteger->setInteger( 99 );
    cout << "setInteger后的值 "<< ( *ptrToInteger ).getInteger()
    << "\n\n程序结束" <<endl;

    return 0;
}

运行结果

创建一个指向Integer的unique_ptr对象
构造 7
setInteger后的值 99

程序结束
析构99
  1. 使用示例3：

当管理数组的unique_ptr超出作用域时，它使用delete[]删除内存，以便数组的每个元素都接收到析构函数调用。

    unique_ptr< string[] > ptr( new string[ 10 ]);
    ptr[ 2 ] = "hello";
    cout << ptr[ 2 ] << endl;

operator new

  1. throwing (默认抛异常版本)
    void* operator new (std::size_t size);
  2. nothrow （不抛异常版本）
    void* operator new (std::size_t size, const std::nothrow_t& nothrow_value) noexcept;
  3. placement
    void* operator new (std::size_t size, void* ptr) noexcept;
  1. 全局 new和delete自定义
include <cstdio>
#include <cstdlib>
#include <new>
 
// 最小函数集的替换： 
// 无 inline ，由 [replacement.functions]/3 要求
void* operator new(std::size_t sz)
{
    std::printf("已调用全局 new 运算符，大小为 %zu\n", sz);
    if (sz == 0)
        ++sz; // 避免 std::malloc(0)，它可能会在成功时返回 nullptr
 
    if (void *ptr = std::malloc(sz))
        return ptr;
 
    throw std::bad_alloc{}; // 由 [new.delete.single]/3 要求
}
 
void operator delete(void* ptr) noexcept
{
    std::puts("已调用全局 delete 运算符");
    std::free(ptr);
}
 
int main()
{
    int* p1 = new int;
    delete p1;
 
    int* p2 = new int[10]; // C++11 中保证调用替换
    delete[] p2;
}

运行结果

已调用全局 new 运算符，大小为 4
已调用全局 delete 运算符
已调用全局 new 运算符，大小为 40
已调用全局 delete 运算符
  1. 类中的operator new
#include <iostream>
#include <new>
#include <memory>
 
 using namespace std;
 class A
{
public:
    A(){
        cout<<"A constructor"<<endl;
    }
    ~A(){
        cout<<"A destructor"<<endl;
    }
    void * operator new (size_t size){
        cout<<"new "<<size<<endl;
        void *p = malloc(size); // ((A*)p)->a = 100;
        return p;
    }
    void operator delete(void *p){
        cout<<"delete"<<endl;
        free(p);
    }
    void * operator new[] (size_t size){
        cout<<"new[] "<<size<<endl;
        return malloc(size);
    }
    void operator delete[](void *p){
        cout<<"delete[] "<<endl;
        free(p);
    }
private:
    int a;
};
 
int main()
{
    A * cp = new A;
    delete cp;
    A * cpa = new A[20];
    delete []cpa;
    return 0;
}

运行结果

标准输出：

new 4
A constructor
A destructor
delete
new[] 88
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A constructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
A destructor
delete[]
  1. 重载placement new
#include <cstdlib>
#include <iostream>
char buf[100];
struct A {} ;
struct E {} ;

class T {
public:
    T() { throw E() ; }
    void * operator new(std::size_t,const A &){
        std::cout << " 调用类T  Placement new " << std::endl;
        return buf;
    }
    void operator delete(void*, const A &){
        std::cout << " 调用类T  Placement delete " << std::endl;
    }
} ;

void * operator new ( std::size_t, const A & ){
	std::cout << " 调用 Placement new " << std::endl; return buf;
}
void operator delete ( void *, const A & ){
	std::cout << " 调用 Placement delete " << std::endl;
}

int main ()
{
    A a ;
    try {
        T * p = new (a) T ;
        /* ... */
    } catch (E exp) {std::cout << " 异常捕获 " << std::endl;}
    return 0 ;
}

运行结果

 调用类T  Placement new 
 调用类T  Placement delete 
 异常捕获

new 表达式和operator new函数

二者区别

  • 操作符vs函数：new既是一个操作符也是一个关键字，而operator new只是一个函数。
  • " new "调用“operator new”：
    “new operator” 调用“operator new()” , 就像+ operator 调用 operator +()
  • “Operator new” 可以被重写：operator new可以重载，就像允许执行定制任务的函数一样
  • 内存分配： ‘new 表达式’ 调用‘operator new’ 分配原始内存，然后调用构造函数

ADL规则

本节我们只做简要的了解，目的是为了知道全局作用域的operator new 和类中的operator new是如何被查找调用的。

定义

实参依赖查找（argument-dependent lookup），又称 ADL 或 Koenig 查找 ，是一组对函数调用表达式（包括对重载运算符的隐式函数调用）中的无限定的函数名进行查找的规则。在通常无限定名字查找所考虑的作用域和命名空间之外，还会在它的各个实参的命名空间中查找这些函数。

标准库示例

#include <vector>
#include <algorithm>
#include <iostream>

int main () {
std::vector<int> v {3,2,1,4};
sort(begin(v), end(v));  //  compiles!
for (auto x : v) std::cout << x << ' ';
std::cout << '\n';
}

查找路径如下：

  1. v的类型是std::vector
  2. ADL 首先在std的命名空间中查找begin和end函数
  3. 找见了std::begin和std::end函数，并且调用它
  4. begin/end的返回类型是std::vector<int>::iterator
  5. ADL在命名空间std中查找sort
  6. 找见std::sort 并调用它

delete operator 和 operator delete 类似，这里不做详述

new和delete的查找过程

当编译器发现一条new表达式或者delete表达式之后，查找过程如下：

  1. 首先在类及其基类的作用域中查找，若该类包含operator new成员或者operator delete成员，则相应的表达式将调用这些成员
  2. 若不满足【1】，编译器在全局作用域查找匹配函数，此时若编译器找到了用于自定义的版本，则使用该版本执行new表达式或者delete表达式；
  3. 若不满足【2】，则使用标准库定义的版本
  4. 需注意：若直接使用::new或者::delete，则直接在全局作用域查找匹配的operator new函数。

术语说明

  1. 内存泄漏

当程序员在堆中创建内存并忘记删除它时，就会发生内存泄漏。
内存泄漏的后果是它通过减少可用内存量来降低计算机的性能。 最终，在最坏的情况下，可能会分配过多的可用内存，并且系统或设备的全部或部分停止正常工作，应用程序失败，或者系统速度大大降低。
对于像守护进程和服务器这样的程序来说，内存泄漏是特别严重的问题，这些程序根据定义永远不会终止。

  1. 栈展开

栈展开（unwinding）是指当前的try...catch...块匹配成功或者匹配不成功异常对象后，从try块内异常对象的抛出位置，到try块的开始处的所有已经执行了各自构造函数的局部变量，按照构造生成顺序的逆序，依次被析构。如果当前函数内对抛出的异常对象匹配不成功，则从最外层的try语句到当前函数体的起始位置处的局部变量也依次被逆序析构，实现栈展开，然后再回退到调用栈的上一层函数内从函数调用点开始继续处理该异常。

catch语句如果匹配异常对象成功，在完成了对catch语句的参数的初始化（对传值参数完成了参数对象的copy构造）之后，对同层级的try块执行栈展开。

由于线程执行时，被调用的函数的参数、返回地址、局部变量等都是依函数调用次序保存在函数调用栈（即线程运行时栈）上。当前被调用函数的参数、局部变量名字可以覆盖掉早前调用函数的同名变量，看起来就是只有当前函数内的名字可以访问，早前调用的函数内部的名字都不可访问，就像磁带被“卷起”。异常处理时按照函数调用顺序的逆序析构，依次析构各个被调函数的局部变量，就类似把已经卷起的“磁带”再展开，抹去上面记录的数据，故此“栈展开”得名。unwinding在物理学、电工学上也翻译做“退绕”、“退卷”。

-西门吹雪
关注
专栏目录
动态内存管理(new/delete)
小葱的博客
03-04 454
拖了这么久，终于有时间把这块的东西总结一下，已经大三下学期了，留给我的时间已经不多了，希望可以抓住大学时光的尾巴，不负父母的殷切期望！ 首先让我们来看看内存的分配方式都有哪些？ 内存的分配方式： ①从静态存储区域分配。 内存在程序编译的时候就已经分配好了，这些内存在程序整个运行期间都存在，如：全局变量、static变量。 ②在堆栈上分配。 在函数执行期间，函数内部变
new和delete的深入分析
蜀沐的博客
11-10 281
1、说明： new new和delete是运算符，不是函数，因此执行效率高和delete是运算符，不是函数，因此执行效率高 malloc和free是函数 2、 new和delete运算符使用的一般格式为： 用new分配数组空间时不能指定初值。如果由于内存不足等原因而无法正常分配空间，则new会返回一个空指针NULL，用户可以根据该指针的值判断分配空间是否成功。 注意：通常情况下，一般用new出来的基础类，数组;free掉也是可以的，malloc和delete也可以配套使用；但对于 “对象”，new和del
new/delete操作符
都是故事
08-07 257
C++中的new操作符有三种使用方式： plain new nothrow new placement new
【C++】new/delete使用
xiaoxiaoguailou的博客
01-07 1076
文章目录（一）new/delete用法（1）申请/释放 单独 堆区空间（2）申请/释放 连续 堆区空间（3）单独空间 申请并初始化（二）new和malloc区别 （一）new/delete用法 （1）申请/释放 单独 堆区空间 int* p = new int; //只进行申请堆区空间sizeof(int)大小 *p = 20; //对申请的空间赋值 delete p; //将p指向的空间还给系统 p = NULL; //将p变量的内容置空 （2）申请/释放 连续 堆区空间 int* p
C++内存分配之new与delete
农家小舍
09-12 480
[TOC] C++中在堆内存中创建和销毁对象需要借助关键字new和delete来完成，new和delete既是C++中的关键字也是一种特殊的运算符。 内存分配 C++中有多种内存分配、释放方式： 分配 释放 类属 可否重载 malloc() free() C函数 不可 new delete C++表达式 不可 ::operator new() ::operator delete() C++函数 可 allocator::allocate() allocator::deallo.
C++基础--- new/delete的使用
小程的博客
05-23 3380
文章目录newdelete new delete
[C++] C++中使用new和delete动态内存分配
FightFightFight的博客
03-15 3673
      在C语言中，我们经常使用char数组来表示一个字符串，如char name[50]表示申请50个字节的内存空间来存储姓名，然而，这种做法有很多缺陷，比如如果有些人姓名长度大于50，那么就要修改内存大小，这样造成了很大的内存浪费。因此，C语言的做法是通过指针来解决这个问题，比如：char * name;//声明char型指针 //申请内存 name = (char *)malloc(si...
new和delete的底层实现原理
赫菲斯托斯，，
05-10 6008
- new/new[]和delete/delete[]是什么？ new/new[]和delete/delete[]是操作符；是C++用来实现动态内存管理的操作符； new/new[] 操作符是用来申请空间的； delete/delete[]操作数是用来释放动态申请出来的空间； - new/delete的实现原理 new和delete是用户进行动态内存申请和释放的操作符，operator new...
new/delete详解(跑路人笔记)＜C++初阶＞
qq_61434711的博客
05-29 2569
文章目录前言new/delete内置类型举例自定义类型举例new失败operator new与operator delete现式调用构造函数new和delete的实现原理malloc/free和new/delete的区别小结 前言 new和delete是C++为了类的使用方便而创造的操作符,我们在使用C++时应该尽量避免使用malloc和free而应该转向使用new和delete. new/delete 内置类型举例 new/delete类似于malloc/free但是为了搭配我们的C++的新知识也就是类的
android jni new/delete 和 new[]/delete[]
谢岩的博客
01-18 1658
今天，简单讲讲android里再jni使用new时如何释放内存。 这个其实是和C++有关的知识，不过jni编程时还是需要注意的。所以这里记录一下。 new 和 delete 到底是什么？ 如果找工作的同学看一些面试的书，我相信都会遇到这样的题：sizeof 不是函数，然后举出一堆的理由来证明 sizeof 不是函数。在这里，和 sizeof 类似，new 和 delete
ardupilot C++堆和栈
陌城烟雨
10-04 602
目录 文章目录目录摘要1.new 和 delete 运算符2.数组的动态内存分配 摘要 了解动态内存在 C++ 中是如何工作的是成为一名合格的 C++ 程序员必不可少的。C++ 程序中的内存分为两个部分： 栈：在函数内部声明的所有变量都将占用栈内存。 堆：这是程序中未使用的内存，在程序运行时可用于动态分配内存。 很多时候，您无法提前预知需要多少内存来存储某个定义变量中的特定信息，所需内存的...
C++ — new和delete的总结
阿亮的博客
03-13 1575
C++动态内存管理 C语言用malloc,calloc,relloc和free来进行动态内存管理。但是在C++中就变得不一样了。 C++通过new和delete动态管理内存。 new/delete动态管理对象。 new[]/delete[]动态管理对象数组。 这里提一下，malloc和free，new和delete，new[]和delete[]一定要成
C malloc函数用法
liuzheng2684的专栏
10-29 1822
函数声明(函数原型)： <br />void *malloc(int size); <br />说明：malloc 向系统申请分配指定size个字节的内存空间。返回类型是 void* 类型。void* 表示未确定类型的指针。C,C++规定，void* 类型可以强制转换为任何其它类型的指针。 <br />从函数声明上可以看出。malloc 和 new 至少有两个不同: new 返回指定类型的指针，并且可以自动计算所需要大小。比如： <br />int *p; <br />p = new int; //返回类型
linux下delete释放不了内存,new了以后，马上delete，但是用prstat, pmap查看，内存不减少，为什么？...
weixin_35433448的博客
05-12 771
new了以后，马上delete，但是用prstat,pmap查看，内存不减少，为什么？1、voidf(){char*p=newchar[1024*1024*4];//用prstat，pmap查看,内存增加了4Msleep(5);delete[]p;//delete完以后，但是用prstat，pmap查看，内存没有减少}...
C++：new与delete
qq_45481606的博客
07-17 3110
C/C++内存分布图 对内存区域划分的原因： int* p = (int*) malloc (sizeof (int)*4) 指针p在栈上开辟，但是p指针指向了堆上的空间从堆上申请空间 class test { private: int _data; int* _p; public: test( ) { _p=new int[10]; cout<<test( )<<endl; } ~test( ) { delete _p[ ]; cout<&
关于c++内存回收（delete）对程序整体运行时间影响的疑问
MorphLing_的博客
11-16 1311
起因是这样的，最近算法课在上红黑树，写红黑树的时候肯定涉及一些内存管理的问题，主要是在插入结点的时候要用new分配一个新的结点，并在清空红黑树的时候把这些结点delete释放掉。 因为要测试多组数据的运行时间，需要实现一个清空(destroy)操作。本着避免一切可能造成的内存泄漏，一开始我写了完整的清空函数，也就是从根节点开始递归，回收每个结点的内存空间，其中我的结点和树定义如下。 enum RBTColor{RED, BLACK}; class RBTNode { public: RBTColo
C++深度解析：new与delete的原理与应用
"深入理解C++的new和delete操作符以及它们在内存管理中的作用" ...在实践中，应谨慎使用`new`和`delete`，避免内存泄漏和悬挂指针，同时考虑使用智能指针（如`std::unique_ptr`和`std::shared_ptr`）来简化内存管理。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

-西门吹雪

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

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

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

打赏作者

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

抵扣说明：

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

余额充值