【C/C++】动态内存管理（C：malloc，realloc，calloc，free || C++：new，delete）

2024-04-30 21:28
文章标签 c++ 管理 动态内存 free new malloc delete calloc realloc

本文主要是介绍【C/C++】动态内存管理（C：malloc，realloc，calloc，free || C++：new，delete），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

在这里插入图片描述

🔥个人主页： Forcible Bug Maker
🔥专栏： C++ | | C语言

目录

  • 前言
  • C/C++内存分布
  • C语言中的动态内存管理：malloc/realloc/realloc/free
    • `malloc`
    • `realloc`
    • `calloc`
    • `free`
  • C++中的动态内存管理：new/delete
    • new和delete操作内置类型
    • new和delete操作自定义类型
    • operator new与operator delete函数
    • new和delete的实现原理
    • 定位new表达式(placement-new)
  • 结语

前言

本篇博客主要内容：C++和C语言的动态内存管理方式，机制以及两者之间的区别。

在学习C语言的过程中，也曾涉及过动态内存管理，我们可以使用malloc，realloc，calloc等函数来动态管理堆中空间资源。而在C++中，有了新的动态内存管理方式，那就是new和delete关键字。忽然发现之前似乎并没有讲C语言的几个动态内存管理函数，所以标题是 【C/C++】动态内存管理 ，不过不止如此，本次还会介绍new，delete关键字的底层，并区分一下C和C++内存管理之间的不同。

C/C++内存分布

在开始讲解之前，想通过一道题引入今天的内容。

#include<iostream>
using namespace std;
int globalVar = 1;
stat/ic 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);
}

数据段就是我们常说的静态区，代码段就是我们所说的常量区。而动态内存管理，主要管理的是堆区中的内存空间。

选择题：
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
①g/lobalVar在哪里？②____ staticGlobalVar在哪里？___
③//staticVar在哪里？___ ④localVar在哪里？____
⑤num1 在哪里？____

  1. globalVal是全局变量，存储在数据段(静态区)。
  2. staticGlobalVal是静态全局变量，同时是静态的，因此它同样存储在数据段(静态区)。
  3. staticVar是静态局部变量，存储在数据段(静态区)，其生命周期贯穿整个程序的执行。
  4. localVar是局部变量，存储在栈上。
  5. num1是局部变量，本质是数组指针（存储着数组首元素地址）存储在栈上。

选择题：
①char2在哪里？____ ②char2在哪里？____
③pChar3在哪里？___ _④pChar3在哪里？_____
⑤ptr1在哪里？____ ⑥*ptr1在哪里？____

  1. char2和num1性质是一样的，为局部变量，是数组首元素地址，存储在栈上。
  2. *char2是栈帧中直接开辟空间存储的数据，在栈上。
  3. pChar3是局部指针变量，存储在栈上。
  4. *pChar3指向的内容（为常量字符串"abcd"）存储在代码段(常量区)。
  5. ptr1是局部指针变量，存储在栈上。
  6. *ptr1指向的内存空间是通过malloc动态开辟的，存储在堆上。
  • *char2（局部字符数组）
    当声明一个局部字符数组并用一个字符串字面量初始化的时候，如char char2[] = "abcd";或char char2[5] = "abcd";时，编译器在栈上会为数组分配内存，然后将字符串字面量的内容（包括结尾的**\0**）复制到这块内存中。因此char2指向的内容存储在栈上。
  • *pChar（字符串字面量指针）
    当你使用指针去指向一个字符串常量（“abcd”）时，由于字符串常量是存储在代码段(常量区) 的，所以必须用const修饰才能接收到常量内容的地址（这样规定的原因是为了防止你对常/量做出修改，此时的"abcd"就跟数字1，2，3等等常量的性质是一样的）。故const char* pChar3 = "abcd";中，尽管pChar是一个指针，存储在栈中，但其却指向的字符串却存储在常量区。

*char2不在常量区，因为char2是局部字符数组，其内容直接存储在栈上。
*pChar3在常量区，是因为它指向的是一个字符串字面量（“abcd”），字符串字面量存储在程序的常量区，这部分内存只能读，不能改动。

在这里插入图片描述

内存主要可以分为几个部分：栈（Stack）、堆（Heap）、数据段（Data Segment）和代码段（Code Segment）。而我们的数据通常也存储在这些地方。

  1. 栈（Stack）：
    自动变量（包括局部变量和函数参数）通常分配在栈上。当函数被调用时，它的参数和局部变量会在栈上分配空间。当函数返回时，这些空间会被自动释放。
    栈内存分配和释放由编译器自动处理，不需要程序员手动管理。
  2. 堆（Heap）：
    通过malloc、calloc、realloc等函数分配的内存位于堆上。堆用于动态内存分配，程序员需要手动管理内存的分配和释放。
    堆上的内存可以在程序的运行期间随时分配和释放，适用于需要动态创建和销毁的对象。
  3. 静态存储区：
    全局变量和静态变量（无论是在函数内部还是外部声明的静态变量）存储在全局/静态存储区。
    这些变量在程序的整个生命周期中都存在，不会被自动释放。它们的初始化发生在程序启动时，释放则发生在程序结束时。
  4. 常量区：
    存储常量字符串和字面量的地方。这些常量在程序的生命周期内都是固定的，不会被修改。

C语言中的动态内存管理：malloc/realloc/realloc/free

C语言里，关于动态内存的管理，是依靠一套标准的库函数完成的，它们包括malloc，realloc，calloc和free。这些函数允许在程序中随时开辟，分配和调整堆中的内存，都统一放在头文件<stdlib.h>中。下面是关于这些函数的基本用法以及它们之间的区别：

malloc

  • 头文件： <stdlib.h>
  • 函数声明： void* malloc(size_t size);
  • 功能： 在堆中开辟指定字节数的未初始化内存，并返回一个指向新开辟内存的指针。如果分配失败，则返回空指针NULL。
  • 示例：
// 为代码开辟了大小能存放四个整型数据的空间
int* ptr = (int*)malloc(sizeof(int) * 4);
// 这个ptr指针，指向内存空间首元素地址
*ptr = 1;
*(ptr + 1) = 2;
*(ptr + 2) = 3;
*(ptr + 3) = 4;
for (int i = 0; i < 4; i++)printf("%d ", *(ptr + i));
printf("\n");

在这里插入图片描述

realloc

  • 头文件： <stdlib.h>
  • 函数声明： void* realloc(void* ptr,size_t size);
  • 功能： 调整之前调用malloc或calloc分配的内存块（传入的ptr为针指向此内存块的指针，如果ptr为NULL，那么realloc的功能就等同于malloc）。如果新的大小大于原始大小，可能会移动内存块到新的位置以提供足够的空间（移动过程也会把内存块中的值相应的拷贝到新的空间）。
  • 示例：
// 为代码开辟了大小能存放四个整型数据的空间
int* ptr = (int*)malloc(sizeof(int) * 4);
// 这个ptr指针，指向内存空间首元素地址
*ptr = 1;
*(ptr + 1) = 2;
*(ptr + 2) = 3;
*(ptr + 3) = 4;
//此时空间已经被放满
ptr = (int*)realloc(ptr, sizeof(int) * 5);
*(ptr + 4) = 5;
for (int i = 0; i < 5; i++)printf("%d ", *(ptr + i));
printf("\n");

在这里插入图片描述
在上面的示例代码中，使用realloc的方式是极其不安全且不被推荐的，当realloc开辟空间失败时，返回值NULL会让原本ptr指向的空间也丢失掉，所以使用realloc时，应该像下面这样。

int* ptr = (int*)malloc(sizeof(int) * 4);
int* tmp = (int*)realloc(ptr, sizeof(int) * 10);
// 判断是否realloc成功
if (tmp == NULL) {perror("realloc fail:");exit(1);
}
// 此时将tmp赋值给ptr就是安全的
ptr = tmp;

calloc

  • 头文件： <stdlib.h>
  • 函数声明： void* calloc(size_t num,size_t size);
  • 功能： 为指定数量的元素分配内存，每个元素的大小在第二个参数中指定，并自动初始化所有位为0。如果分配失败，返回NULL。
  • 示例：
// 为代码开辟了大小能存放四个整型数据的空间
// 同时初始化所有位为0
int* ptr = (int*)calloc(4, sizeof(int));
for (int i = 0; i < 4; i++)printf("%d ", *(ptr + i));
printf("\n");
// 这个ptr指针，指向内存空间首元素地址,
*ptr = 1;
*(ptr + 1) = 2;
*(ptr + 2) = 3;
*(ptr + 3) = 4;
for (int i = 0; i < 4; i++)printf("%d ", *(ptr + i));
printf("\n");

在这里插入图片描述

free

  • 头文件： <stdlib.h>
  • 函数声明： void free(void ptr);
  • 功能： 释放之前通过malloc，calloc或realloc分配的内存。一但内存被释放，被释放那块内存就不能再被访问了。
  • 示例：
int* ptr1 = (int*)malloc(sizeof(int) * 4);int* ptr2 = (int*)malloc(sizeof(int) * 4);
int* ptr2 = (int*)realloc(ptr2, sizeof(int) * 10);int* ptr3 = (int*)calloc(4, sizeof(int));free(ptr1);
free(ptr2);
free(ptr3);

注：
在你开辟使用完堆中内存但忘记free释放时，编译器不会报错，但是被开辟的这块空间会一直存在于堆中，无法再次被开辟使用，导致内存泄露。内存泄露在大型项目中是个严重的暗病，不会立即显示，但是非常可能会在项目运行时冷不丁让空间开辟失败导致程序崩溃。
同时，不要尝试去释放未经分配的内存块或者多次释放同一个内存块，可能会导致未定义的行为，因此，每个分配的内存块至多free一次。

C++中的动态内存管理：new/delete

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

  • new：
    用于在运行时动态的分配内存并返回该内存的指针。它可以与数据类型一起使用，以指定要分配的内存大小和类型。例如，int* p = new int;这行代码会分配一个足以存储int类型数据的内存块，并将返回的地址赋值给指针p。
  • delete：
    用于释放由new分配的内存。在C++中，必须显示释放不再需要的内存，以防止内存泄漏。delete运算符接受一个指针作为参数，并释放该指针指向的内存。例如，delete p;这行代码会释放之前由new为p分配的内存。

接下来，我们详细讲讲new和delete的用法。

new和delete操作内置类型

在这里插入图片描述
申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]。
下面可以来看一组代码案例：

// 动态申请一个int类型的空间
int* ptr1 = new int;
cout << *ptr1 << endl;// 动态申请一个int类型的空间并初始化为10
int* ptr2 = new int(10);
cout << *ptr2 << endl;// 动态申请10个int类型的空间
int* ptr3 = new int[3];
for (int i = 0; i < 3; i++)cout << *(ptr3 + i) << " ";
cout << endl;// 动态申请10个int类型的空间，并初始化
int* ptr4 = new int[3] {1, 2};
for (int i = 0; i < 3; i++)cout << *(ptr4 + i) << " ";
cout << endl;delete ptr1;
delete ptr2;
// 释放数组空间delete之后指针之前要加[]
delete[] ptr3;
delete[] ptr4;

以下是此段代码运行结果：
在这里插入图片描述
可以看出，单纯的new不会自动给内置类型初始化。所以，如果需要特定的值，需要像ptr2那样给动态申请的空间初始化。
通过ptr3和ptr4的对比，会发现，new同样不会对动态开辟的数组进行初始化，但是可以通过ptr4初始化数组的方式，此时，未被赋值的类型会自动初始化成0。

new和delete操作自定义类型

单纯拿new和delete对内置类型的操作来说，其实与C语言想必并没有什么太大的优势。但是C++中多了类这一个新的内容之后，new和delete就大有用武之地了。在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。 自动调用构造和析构的作用可不小，当你的自定义类型有一个指针指向某一块资源的时候，就非常有必要了。自动调用构造和析构可以帮助你在动态内存管理的过程中自动开辟和释放指对象中的针指向的资源，很大程度上避免了空指针和内存泄露等问题。
下面可以看一段代码案例帮助理解：

#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()
{// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】// 除了开空间还会调用构造函数和析构函数A* p1 = (A*)malloc(sizeof(A));A* p2 = new A(1);free(p1);delete p2;cout << endl;// 内置类型是几乎是一样的int* p3 = (int*)malloc(sizeof(int)); // Cint* p4 = new int;free(p3);delete p4;A* p5 = (A*)malloc(sizeof(A) * 10);A* p6 = new A[10];// 自动调用10次构造和析构free(p5);delete[] p6;cout << endl;return 0;
}

在这里插入图片描述

注：new和delete需要匹配使用，不要和C语言中的动态内存管理函数交叉，否则运行的结果是未定义的。

operator new与operator delete函数

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

我们可以简单来看一下，operator new与operator delete的全局定义：

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
失败，尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否
则抛异常。
*/
void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{// try to allocate size bytesvoid* p;while ((p = malloc(size)) == 0)if (_callnewh(size) == 0){// report no memory// 如果申请内存失败了，这里会抛出bad_alloc 类型异常static const std::bad_alloc nomem;_RAISE(nomem);}return (p);
}/*
operator delete: 该函数最终是通过free来释放空间的
*/
void operator delete(void* pUserData)
{_CrtMemBlockHeader* pHead;RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));if (pUserData == NULL)return;_mlock(_HEAP_LOCK); /* block other threads */__TRY/* get a pointer to memory block header */pHead = pHdr(pUserData);/* verify block type */_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));_free_dbg(pUserData, pHead->nBlockUse);__FINALLY_munlock(_HEAP_LOCK); /* release other threads */__END_TRY_FINALLYreturn;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

new和delete的实现原理

本质上说，new实际上就是operator new的一个封装，而operator new又是malloc的一个封装；delete实际上就是operator delete的一个封装，而operator delete又是free的一个封装。
在这里插入图片描述

  • 内置类型：
    如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
  • 自定义类型：
    • new的原理
      1. 调用operator new函数申请空间
      2. 在申请的空间上执行构造函数，完成对象的构造
    • delete的原理
      1. 在空间上执行析构函数，完成对象中资源的清理工作
      2. 调用operator delete函数释放对象的空间
    • new T[N]的原理
      1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
      2. 在申请的空间上执行N次构造函数
    • delete[]的原理
      1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
      2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

定位new表达式(placement-new)

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

使用格式：
new (place_address) type 或new(place_address)type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表。

定位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;}int _a;
};
// 定位new/replacement new使用演示
int main()
{// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行A* p1 = (A*)malloc(sizeof(A));new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参p1->~A();free(p1);cout << endl;A* p2 = (A*)operator new(sizeof(A));new(p2)A(10);p2->~A();operator delete(p2);cout << endl;// 当你想创建多个对象，可以考虑使用循环A* p3 = (A*)operator new(sizeof(A) * 4);for (int i = 0; i < 4; i++)new(p3 + i)A(10);for (int i = 0; i < 4; i++)cout << (p3 + i)->_a << " ";cout << endl;for (int i = 0; i < 4; i++)(p3 + i)->~A();cout << endl;// 要创建多个对象时，也可以这样使用定位new，编译器支持A* p4 = (A*)malloc(sizeof(A) * 4);new(p4)A[4] {1, 2, 3};for (int i = 0; i < 4; i++)cout << (p4 + i)->_a << " ";cout << endl;for (int i = 0; i < 4; i++)(p4 + i)->~A();free(p4);cout << endl;return 0;
}

运行结果如图：
在这里插入图片描述

结语

本篇博客详细讲解了C和C++中动态内存管理的方式，在C语言中，可以使用，malloc，realloc，calloc和free这四个函数进行动态内存管理；在C++中虽然也支持使用C中的四个函数，但新增的new和delete关键字能自动调用自定义类型的拷贝构造函数和析构函数，且开辟或释放失败后不再返回空指针，而是抛异常。我们同样讲到了operator new和operator delete这两个全局函数，它们通过封装能得到我们的new和delete。最后提到了定位new，可以支持给已经开辟的自定义类型空间进行构造或赋值。 关于内存管理的内容还不止于此，在后期的C++11的内容中，会讲到智能指针，内存泄露问题的规避管理等等知识。
博主后续还会产出更多有意思的内容，感谢大家的支持！♥

这篇关于【C/C++】动态内存管理（C：malloc，realloc，calloc，free || C++：new，delete）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/949962。

相关文章

【C++ Primer Plus习题】13.4

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<
阅读更多...
C++包装器

C++包装器

包装器 在 C++ 中，“包装器”通常指的是一种设计模式或编程技巧，用于封装其他代码或对象，使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍，可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型： 1. 函数包装器 函数包装器用于封装一个或多个函数，使其接口更统一或更便于调用。例如，std::function 是一个通用的函数包装器，它可以存储任意可调用对象（函数、函数
阅读更多...
综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

LntonAIServer视频质量诊断功能中的抖动检测是一个专门针对视频稳定性进行分析的功能。抖动通常是指视频帧之间的不必要运动，这种运动可能是由于摄像机的移动、传输中的错误或编解码问题导致的。抖动检测对于确保视频内容的平滑性和观看体验至关重要。 优势 1. 提高图像质量 - 清晰度提升：减少抖动，提高图像的清晰度和细节表现力，使得监控画面更加真实可信。 - 细节增强：在低光条件下，抖
阅读更多...
C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页： 南桥几晴秋 🌈C++专栏： 南桥谈C++ 🌈C语言专栏： C语言学习系列 🌈Linux学习专栏： 南桥谈Linux 🌈数据结构学习专栏： 数据结构杂谈 🌈数据库学习专栏： 南桥谈MySQL 🌈Qt学习专栏： 南桥谈Qt 🌈菜鸡代码练习： 练习随想记录 🌈git学习： 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�
阅读更多...
【C++】_list常用方法解析及模拟实现

【C++】_list常用方法解析及模拟实现

相信自己的力量，只要对自己始终保持信心，尽自己最大努力去完成任何事，就算事情最终结果是失败了，努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一：什么是list？ •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二：list常用接口 •🌰1.默认成员函数 🔥构造函数（⭐） 🔥析构函数 •🌰2.list对象
阅读更多...
06 C++Lambda表达式

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获：包含零个或者多个捕获符的逗号分隔列表 模板形参：用于泛型lambda提供个模板形参的名
阅读更多...
软考系统规划与管理师考试证书含金量高吗？

软考系统规划与管理师考试证书含金量高吗？

2024年软考系统规划与管理师考试报名时间节点： 报名时间：2024年上半年软考将于3月中旬陆续开始报名 考试时间：上半年5月25日到28日，下半年11月9日到12日 分数线：所有科目成绩均须达到45分以上（包括45分）方可通过考试 成绩查询：可在“中国计算机技术职业资格网”上查询软考成绩 出成绩时间：预计在11月左右 证书领取时间：一般在考试成绩公布后3~4个月，各地领取时间有所不同
阅读更多...
安全管理体系化的智慧油站开源了。

安全管理体系化的智慧油站开源了。

AI视频监控平台简介 AI视频监控平台是一款功能强大且简单易用的实时算法视频监控系统。它的愿景是最底层打通各大芯片厂商相互间的壁垒，省去繁琐重复的适配流程，实现芯片、算法、应用的全流程组合，从而大大减少企业级应用约95%的开发成本。用户只需在界面上进行简单的操作，就可以实现全视频的接入及布控。摄像头管理模块用于多种终端设备、智能设备的接入及管理。平台支持包括摄像头等终端感知设备接入，为整个平台提
阅读更多...
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

上篇：6.1.数据结构-c/c++模拟实现堆上篇（向下，上调整算法，建堆，增删数据）-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小)： 2.2 C语言代码（手写堆） 2.3 C++代码（使用优先级队列 priority_queue）
阅读更多...
【C++高阶】C++类型转换全攻略：深入理解并高效应用

【C++高阶】C++类型转换全攻略：深入理解并高效应用

📝个人主页🌹：Eternity._ ⏩收录专栏⏪：C++ “ 登神长阶 ” 🤡往期回顾🤡：C++ 智能指针 🌹🌹期待您的关注 🌹🌹 ❀C++的类型转换 📒1. C语言中的类型转换📚2. C++强制类型转换⛰️static_cast🌞reinterpret_cast⭐const_cast🍁dynamic_cast 📜3. C++强制类型转换的原因📝
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2