初阶3 C/C++内存管理

最新推荐文章于 2025-04-23 10:43:59 发布
最新推荐文章于 2025-04-23 10:43:59 发布
阅读量1.3k 收藏 20
点赞数 39
分类专栏： C++ 文章标签： c语言 c++ java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ydm_ymz/article/details/146477768
版权

本章重点

  1. C/C++内存分布
  2. C语言中动态内存管理方式
  3. C++中动态内存管理
  4. 常见问题

1.C/C++的内存分布

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";
	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);
}
  1. 选择题：
    选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
    globalVar在哪里？____ staticGlobalVar在哪里？____
    staticVar在哪里？____ localVar在哪里？____
    num1 在哪里？____
    char2在哪里？____ *char2在哪里？___
    pChar3在哪里？____ *pChar3在哪里？____
    ptr1在哪里？____ *ptr1在哪里？____
  2. 填空题：
    sizeof(num1) = ____;
    sizeof(char2) = ____; strlen(char2) = ____;
    sizeof(pChar3) = ____; strlen(pChar3) = ____;
    sizeof(ptr1) = ____;
  3. sizeof 和 strlen 区别？

请添加图片描述

答案:

1.
//globalVar 存储于 数据段

//staticGlobalVar 存储于 数据段

//staticVar 存储于 数据段

//localVar 存储于 栈

//localVar1 存储于 栈

//num1 存储于 栈

//char2 存储于 栈
//因为 char2 是一个数组，存在栈上面的，而 “abcd” 是存在常量区的常量，只是拷贝给了 char2

//*char2 存储于 栈
//数组名就是首元素的地址，也就是 char 是地址，*char2 相当于对 cahr2 进行解引用，找到它的内容，那么它的内容是存储在栈上面的

//pChar3 存储于 栈
//pChar3 是一个指针变量，这个指针变量是在栈上面开的

//*pChar3 存储于 代码段
//pChar3 是一个指针变量，它存的是一个地址，它指向常量区的字符串 “a b c d”，*pChar 就是对这个指针变量解引用，找到了它的内容，也就是 “abcd” ，所以它是存在代码段的

//ptr1 存储于 栈

//*ptr1 存储于 堆
2.
注意：sizeof 是求字节大小，strlen 是求字符串长度的。
 
sizeof(num1) = 40（算对象占用空间的大小）
 
sizeof(char2) = 5（char2 是一个字符数组，求大小要计算 ‘\0’）
 
sizeof(pChar3) = 4/8 （指针在 32 位平台大小是 4，64 位平台大小是 8）
 
sizeof(ptr1) = 4/8
 
strlen(char2) = 4（char2 是一个字符数组，求长度不计算 \0）
 
strlen(pChar3) = 4

说明：

  1. 栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
  2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。
  3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
  4. 数据段–存储全局数据和静态数据。
  5. 代码段–可执行的代码/只读常量。

2.C语言中动态内存管理方式:malloc/calloc/realloc/free

void Test ()
{
	int* p1 = (int*) malloc(sizeof(int));
	free(p1);
	// 1.malloc/calloc/realloc的区别是什么？
	int* p2 = (int*)calloc(4, sizeof (int));
	int* p3 = (int*)realloc(p2, sizeof(int)*10);
	// 这里需要free(p2)吗？不需要
	free(p3 );
}

注意：

  • 原地扩。需扩展的空间后方有足够的空间可供扩展，此时，realloc 函数直接在原空间后方进行扩展，并返回该内存空间首地址（即原来的首地址）。
  • 异地扩。需扩展的空间后方没有足够的空间可供扩展，此时，realloc 函数会在堆区中重新找一块满足要求的内存空间，把原空间内的数据拷贝到新空间中，并主动将原空间内存释放（即还给操作系统），返回新内存空间的首地址。
  • 扩容失败。需扩展的空间后方没有足够的空间可供扩展，并且堆区中也没有符合需要开辟的内存大小的空间。结果就是开辟内存失败，返回一个 NULL（空指针）。

3.C++内存管理方式

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

3.1 new和delete的基本操作

（1）new 一个 int 类型的对象

int main()
{
	// 用malloc动态申请一个int类型的空间
	int* p1 = (int*)malloc(sizeof(int));
	// 销毁p1
	free(p1);
 
 
	// 动态申请一个int类型的空间
	int* p1 = new int;
	// 销毁p1
	delete p1;
 
	return 0;
}

（2）new 10 个 int 类型的对象

int main()
{
	// 用malloc动态申请一个int类型的空间
	int* p2 = (int*)malloc(10 * sizeof(int));
	// 销毁
	free(p2);
 
 
	// 动态申请一个int类型的空间
	int* p2 = new int[10];
	// 销毁
	delete[] p2;
 
	return 0;
}

delete[ ] 对应的是new[ ] ，是申请多个空间时的样子。

（3）new 一个 int 类型对象，然后初始化为 10

{
	int* p3 = (int*)malloc(sizeof(int));
	*p3 = 10; //赋值
	//销毁
	free(p3);
 
 
	// 动态申请一个int类型的空间并初始化为10
	int* p3 = new int(10);
	// 销毁
	delete p3;
 
	return 0;
}

（4）new 10 个 int 类型对象，并进行初始化

int main()
{
	//动态申请10个int类型的空间并初始化为1到10
	int* p8 = (int*)malloc(sizeof(int) * 10); //申请
	for (int i = 0; i < 10; i++) //赋值
	{
		p8[i] = i;
	}
	free(p8); //销毁
 
	//动态申请10个int类型的空间并初始化为1到10
	int* p4 = new int[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	//销毁p4
	delete[] p4;
 
	return 0;
}

当然如用new在赋值的时候，如果只给前面的控件赋值，后面的空间会赋值为0

3.2 new和delete操作符自定义类型

对于内置类型来说，malloc 和 new 用法几乎一样，
但是对于自定义类型来说，new和delete相比于malloc，会调用构造函数和析构函数

这里以链表为列，看看malloc和new的区别

malloc：单纯开空间

//链表
struct ListNode
{
    ListNode* next;
    int val;
};
 
//申请节点
struct ListNode* BuyListNode(int x) 
{
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    assert(node);
 
    node->next = NULL;
    node->val = x;
    return node;
}
 
int main()
{
    // 定义n1节点
    struct ListNode* n1 = BuyListNode(1);
    free(n1);
    return 0;
}

new：开空间+调用构造函数初始化

//链表
class ListNode
{
public:
    //构造函数
    ListNode(int val = 0)
        :_next(nullptr), _val(val) // 初始化列表
    {
        cout << "ListNode" << endl;
    }
    ~ListNode()
    {
        cout << "~ListNode" << endl;
 
    }
private:
    ListNode* _next;
    int _val;
};
 
int main()
{
    // 定义n2节点
    ListNode* n2 = new ListNode(2); // new会去调用ListNode的构造函数
    delete n2;
 
    return 0;
}

#include<iostream>
using namespace ::std;
class Date
{
public:
	Date(int year)
	{
		cout << "Date" << endl;
		_year = year;
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year;
};
int main()
{
	Date* p = new Date(1);
	delete p;
	Date* p1 = new Date[4]{1,2,3,4};//支持隐式类型转换
	delete[] p1;
	Date* p2 = new Date[4]{ Date(1949),Date(2019),Date(2022),Date(2023) };
	delete[] p2;
	return 0;
}

总结：

  1. malloc/free 是函数，而 new/delete是关键字
  2. C++ 中如果是申请内置类型的对象或是数组，用 new/delete 和 malloc/free 没有什么区别。
  3. 如果是自定义类型的话，new 和 delete 分别是 开空间+构造函数、析构函数+释放空间，而 malloc 和 free 仅仅是 开空间和释放空间，可以看到区别还是很大的。
  4. 建议在 C++ 中无论是内置类型还是自定义类型的申请和释放，尽量都使用 new 和 delete。

3.3 operator new与operator delete函数

补充：
异常，简单地说就是代码执行到某处中断了，无法继续执行，这时的情况就叫异常。
平常我们在遇到对空指针解引用的情况时，就是出现异常了。

请添加图片描述

  1. 解读operate new源代码
void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
	void* p;
	while ((p = malloc(size)) == 0)
		if (_callnewh(size) == 0)
		{
			// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
			static const std::bad_alloc nomem;
			_RAISE(nomem);
		}
	return (p);
}

请添加图片描述

  • 因此：operate new 是一个函数，调用了malloc，并且如果开辟失败会出现异常。
  • 为什么要这样做呢？因为面向对象语言不喜欢用返回值来处理问题，而更喜欢使用抛异常，来解决问题，通过异常我们可以判断出现了什么情况的错误。
  1. 解读operate delete源代码
void operator delete(void* pUserData)
{
	_CrtMemBlockHeader* pHead;
	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
	if (pUserData == NULL)
		return;
		
	_mlock(_HEAP_LOCK);
	__TRY
	pHead = pHdr(pUserData);
	_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
	_free_dbg(pUserData, pHead->nBlockUse);
	__FINALLY
		_munlock(_HEAP_LOCK); 
	__END_TRY_FINALLY
		return;
}

请添加图片描述

因此：operate delete释放空间的操作跟free本质上是相同的。

3.4 new和delete的实现原理

内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，
不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

自定义类型

new的原理:
开空间(operator new–>malloc)+构造函数

  1. 调用operator new函数申请空间
  2. 在申请的空间上执行构造函数，完成对象的构造

delete的原理:
析构函数+释放空间(operator delete–>free)

  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来释放空间

3.5 定位new

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

#include<iostream>
using namespace ::std;
int main()
{
	Date* p2 = (Date *)operator new(sizeof(Date));
	new(p2)Date(1);//如果有默认构造,括号可以不写。
	delete p2;
	return 0;
}

一般我们会在池化技术中使用，来提高效率。

4.常见问题

4.1 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在释放空间前会调用析构函数完成空间中资源的清理

4.2 内存泄漏

内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。
看这样一段代码：

#include<iostream>
using namespace ::std;
int main()
{
	char* p = new char[1024 * 1024 * 1024];
	return 0;
}

这个程序在编译器上会导致内存泄漏吗？
答案是——不会的。因为编译器会在程序结束时，帮你释放这些空间，这就跟手机卡了，关机再重启的道理是一样的，但是如果是一个24*7小时不停的程序呢？比如服务器，如果存在内存泄漏，如果说大了很快就会被检查出来，但是如果一次只泄漏几个字节，那么这台服务器会越用越卡，最终导致服务器宕机——出事故了，那相关人员就得跟着遭殃…

分类

  1. 系统资源泄漏：
    指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
  2. 堆内存泄漏(Heap leak)
    堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

那该如何解决内存泄漏呢？

  1. 养成良好的编程习惯，对开辟的空间即用即销毁。
  2. 合理利用检查内存泄漏的工具，通常这类工具比较昂贵。
  3. 利用RAII思想——资源获取即初始化，或者智能指针——充分地体现了RAII思想。
  4. 公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
  5. 私有内存管理库，就是公司内部实现的，这套库自带内存检查功能。

总的来看无非就两类：用良好的习惯，规范，思想，尽可能的减少出错的几率。出了问题用现成的工具去检测问题，及时的改正问题。

资源泄漏：包括但不限于内存泄漏，比如说服务端保存数据，结果服务器有段时间崩了，从而导致客户的数据有所损失，或者在保存数据时，没有及时的读入数据从而导致数据的丢失，等等这都算是资源的泄漏。

C++初阶：C/C++内存管理、new与delete详解
qq_74415153的博客
01-29 1801
1.C/C++内存分布 2.C语言中动态内存管理方式 malloc/calloc/realloc/free 3.C++动态内存管理方式 3.1new/delete操作内置类型 3.2new和delete操作自定义类型 4.operator new与operator delete函数 5.new和delete的实现原理 5.1内置类型 5.2自定义类型 6.定位new表达式(placement-new) 7.知识点梳理 malloc/free和new/delete的区别
【C++初阶】C/C++内存管理
2301_78022459的博客
07-17 1003
【C++初阶】C/C++内存管理
C++初阶：C/C++内存管理
L18623384951的博客
09-22 1092
本文主要讲述了，C/C++的内存分布，并着重讲解了new/delete和malloc/free的区别。
C++初阶 —— C/C++内存管理
NapoleonCoder的博客
10-30 1020
new/delete内存管理！
C++初阶-C/C++内存管理
~
12-21 436
C/C++内存管理零、前言一、C/C++内存分布二、C语言动态内存管理三、C++动态内存管理四、operator new与operator delete函数1、operator new与operator delete函数2、operator new与operator delete的类专属重载五、new和delete的实现原理1、内置类型2、自定义类型六、定位new表达式(placement-new)七、常见面试题1、malloc/free和new/delete的区别2、内存泄漏3、如何一次在堆上申请4G的.
(C++初阶) C/C++内存管理
qq_57594025的博客
06-29 392
目录1. C/C++内存分布1.1 总结2. C语言中动态内存管理方式2.1 malloc/calloc/realloc和free2.2 malloc/calloc/realloc的区别3. C++中动态内存管理3.1 概念：3.2 new delete 与malloc free 的区别3.3 示例4. operator new与operator delete函数4.1 概念5. new和delete的实现原理5.1 内置类型5.2 自定义类型6. 定位new表达式(placement-new)6.1 概念
【C++初阶】C/C++内存管理（没有对象那就new一个）
Weraphael的博客
06-04 508
【C++初阶】C/C++内存管理（没有对象的都进来看看吧~），内附面试题
C++初阶:3.C/C++内存管理
Open__Ai的博客
04-01 1641
int main()// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数free(p1);delete p2;// 内置类型是几乎是一样的// Cfree(p3);delete p4;free(p5);return 0;
Lesson05（初阶）--C/C++内存管理
m0_67371175的博客
08-23 941
为了方便管理内存被分为了以上的区域我们来看下面的一段代码和相关问题 1. 选择题： 1.C：全局变量都在静态区 2.C:3.C：用static修饰的局部变量也在静态区4.A:局部变量都在栈上 5.A1. A：char2还是一个数组它就在栈上2.A：*char2，数组名解引用结果是数组的第一个，所以还是在栈上3.A：pchar3是一个指针类型所以也是在栈上4.D：pChar它解引用是"abcd"，通过解引用以后也无法对原来的数据进行修改，"abcd"本质就是代码段5.A：也是一个
OJ.zip_Windows编程_C/C++_
08-09
"C/C++"则是指使用这两种编程语言进行编程，C++是C语言的扩展，增加了面向对象编程的概念，两者在Windows编程中都非常常见且强大。 【压缩包子文件的文件名称列表】列举了10个cpp源代码文件，每个文件名可能是对应...
『C++初阶』第三章-C/C++内存管理
m0_54443558的博客
05-24 1003
C/C++ 内存管理，new，delete 的底层原理，内存泄漏，相关面试题
【C++】C/C++内存管理（new和delete详解）
分享学习方面的一些笔记
09-12 2584
C++内存管理：new和delete细节
C语言高频面试题——指针函数和函数指针的区别
weixin_45252056的博客
04-22 699
是两个容易混淆的概念，但它们的功能和用途完全不同。以下是详细的对比分析，帮助你彻底理解它们的区别。
Win10 C盘空间不足清理方法
topfine的博客
04-20 903
轻松释放Win10 C盘空间
第2章 C语言概述
最新发布
yyhshm520的博客
04-23 683
我有一些C基础，只是没系统学，这章练习太简单，不写代码了。如果是初学者，根据我学习汇编的经验，再简单都要写，代码看的懂和写的出是两回事，关键就在写。以前分析复杂的指针和typedef构造的别名时，总是判断不清楚，就是忽略这句话“可以通过圆括号识别一个函数名”程序由一个或多个函数组成，其中必须有一个名为main()的函数。而函数体位于花括号中并由一系列语句组成，每个语句以一个分号结束。
c++中的类有关概念
m0_66655785的博客
04-19 133
在 C++ 中，**类（Class）** 是面向对象编程（OOP）的核心概念，用于封装数据和行为。以下是关于类的主要概念和用法：
C/C++条件预编译指令（宏定义）
m0_56844552的博客
04-22 424
自定义宏一定在.pro文件中添加宏定义或手动通过。
基于C++和Qt开发IEC104规约主站调试软件（第六章）终
liangwwe0的博客
04-22 499
本章节主要讲解功能按钮的功能实现和核心代码，结合前五个章节的内容，即可完成IEC104主站调试软件开发应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值