【C++】007 C/C++ 内存管理机制、malloc与new的区别及模板初阶

如意猴2026-10-05 15:48

一. C/C++内存分布

注意：栈中存放局部变量；静态区存放全局变量、静态数据（包括全局的和局部的）；常量区存放常量或者代码编译好的指令；堆中存放动态申请的变量或对象，动态数组。

我们先来看下面的一段代码和相关问题：

cpp 复制代码 
#include<iostream>
using namespace std;

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);
  
   const int i=10;
   int j=1;
}

1.选择题

选项：A.栈 B.堆 C.数据段（静态区） D.代码段（常量区）

（1）globalvar在哪里？ 选C，因为其属于全局变量。

（2）staticGlobalvar在哪里？ 选C，因为其属于静态的全局数据。

（3）staticVar在哪里？ 选C，因为其属于静态的局部数据。

（4）localvar在哪里？ 选A，因为其属于局部变量。

（5）num1在哪里？ 选A，因为局部的数组也在栈上。

（6）char2在哪里？ 选A，因为它是一个数组，注意数组名是代表整个数组的。

（7）*char2在哪里？ 选A，*char代表数组首元素的地址，首元素在栈上，故解引用也是在栈上。

（8）pChar3在哪里？ 选A，const修饰的是指向的内容，不是修饰本身，就算修饰本身，也是在栈上。

（9）*pChar3在哪里？ 选D， pChar3在栈上面，在栈上面解引用，找它指向的内容，指向常量字符串，常量字符串在常量区。（常量区的数据不能修改）

（10）ptr1在哪里？ 选A，ptr1是int型的指针变量，ptr1存了一块堆上的一块空间地址。

（11）*ptr1在哪里？ 选B。

（12）i在哪里？ 选A。注意这里的i不是存放在常量区，C++中const修饰的变量叫做常变量，它只不过是不能修改罢了，但是想办法是可以修改到的：取到它的地址是const int*，再把它强制转换成int*再去解引用是能修改的。所以它在栈上。

【说明】

a.栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。

b.内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信。

c.堆用于程序运行时动态内存分配，堆是可以上增长的。

d.数据段--存储全局数据和静态数据。

e.代码段--可执行的代码/只读常量。

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

2.1 malloc/calloc/realloc的区别？

malloc是动态开辟；calloc动态开辟会初始化，默认会把初始化的空间初始化成0；realloc是对已有的一块空间进行扩容，realloc的性能是很不确定的，它又分为原地扩容 和异地扩容。

cpp 复制代码 
#include<iostream>
using namespace std;
int main()
{
	int* p2 = (int*)calloc(4 , sizeof(int));
	int* p3 = (int*)realloc(p2, sizeof(int) * 10);
	cout << p2 << endl;
	cout << p3 << endl;
	//这里需要free(p2)么？
	free(p3);
	return 0;
}

这里完全不需要free(p2)，因为这里的realloc有可能是原地扩容也有可能是异地扩容，由运行结果可知此处是原地扩容，原地扩容的话二者地址一样，释放一次就可以了，如果再free(p2)，就会对同一块空间释放两次，而不允许对同一块空间释放两次。但是，如果是异地扩容，也不需要我们free(p2)，因为此时realloc会帮我们释放掉。

三. C++内存管理方式

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

3.1 new/delete操作内置类型

"new+类型"代表申请这个类型的对象，然后返回"类型*"，例如，"new int"代表动态申请一个int类型的对象。注意new默认是不会初始化的，想初始化的话就像如图函数体中第二行所示。

cpp 复制代码 
int* ptr7=new int[10]{1,2,3,10}; //数组
//前4个数为1,2,3,10，后面依次补0

delete ptr4;
delete[] ptr7;

单个对象是delete，多个对象是delete 。其实我们就可以认为new在这块涵盖了malloc和calloc的所有功能。

3.2 new和delete操作自定义类型

cpp 复制代码 
#include<iostream>
using namespace std;
class A {
	A(int a = 0)
		:_a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A()" <<this<< endl;
	}
private:
	int _a;
};
struct ListNode
{
	ListNode* _next;
	int _val;
	ListNode(int val)
		:_next(nullptr)
		,_val(val)
	{ }
};
int main()
{
	//只开空间，不调用构造初始化
	A* p1 = (A*)malloc(sizeof(A));
	//除了开空间，还会调用构造函数初始化
	A* p2 = new A;
	A* p3 = new A(10);
	//delete会调用析构函数
	delete p2;
	delete p3;

	ListNode* n1 = new ListNode(1);
	ListNode* n2 = new ListNode(2);
	ListNode* n3 = new ListNode(3);
	return 0;
}

new会失败吗？一般情况下，new和malloc都极少失败，malloc和calloc失败都会返回空指针。new失败会出现"抛异常"，我们要做的就是"捕获异常"，用"try...catch"的方式去捕获，由于这里的内容有些高深，所以我在这里仅仅展示一下用法就行 ，后面我会讲到。

cpp 复制代码 
#include<iostream>
using namespace std;
int main()
{
	try 
	{
		int i = 1;
		int* ptr = nullptr;
		do {
			ptr = new int[1024 * 1024];
			cout << i++ << ":" << ptr << endl;
		} while (ptr);
		cout << i++ << ":" << ptr << endl;
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;//会打印出错误
	}
	return 0;
}

四. operator new与operator delete函数

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

五. new和delete的实现原理

5.1 内置类型

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

5.2 自定义类型

**（1）new的原理：**①调用operator new申请函数空间。②在申请的空间上执行构造函数，完成对象的构造。

**（2）delete的原理：**①在空间上执行析构函数，完成对象中资源清理的工作。②调用operator delete函数释放对象的空间。

（3）new TN的原理：①调用operator new\[\]函数，在operator new\[\]中实际调用operator new函数完成N个对象空间的申请。②在申请的空间上执行N次构造函数。

**（4）delete\[\]的原理：**①在释放的对象空间上执行N次构造函数，完成N个对象中资源的清理。②调用operator delete\[\]释放空间，实际在operator delete\[\]调用operator delete来释放空间。

六. 定位new表达式(placement-new)（了解）

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

6.1 使用格式：

new(place_address)type或者new(place_address)type(initalizer-list)，place_address必须是一个指针，initializer-list是类型的初始化列表。

6.2 使用场景

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。（也就是说觉得系统的malloc内存池不够高效，要搞一套自己的这个管理内存的这样一个机制，这个机制默认只开了空间出来，开了空间出来我要想初始化，就得显式调用构造，显式调用构造就得用定位new）。

cpp 复制代码 
#include<iostream>
using namespace std;
class A {
public:
	A(int a)
		:_a(a)
	{
		cout << "A():" <<this<< endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	A* ptr = (A*)operator new(sizeof(A));
	//显式调用构造函数--构造函数只能通过定位new去调用
	new(ptr)A(1);

	ptr->~A();//析构函数可以显式调用
	operator delete(ptr);
	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在释放空间前会调用析构函数完成空间中资源的清理释放。

七. 模板初阶

7.1 泛型编程

如何实现一个通用的交换函数呢？

cpp 复制代码 
#include<iostream>
using namespace std;
void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}
void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
}
void Swap(char& left, char& right)
{
	char temp = left;
	left = right;
	right = temp;
}
.......

使用函数重载虽然可以实现，但是有以下几个不好的地方：

  1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数。

  2. 代码的可维护性比较低，一个出错可能所有的重载均出错。

那是否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？

泛型编程的概念：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

模板分为函数模板和类模板两类。

7.2 函数模板

7.2.1 函数模板概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

7.2.2 函数模板格式

template<typename T1，typename T2，........，typename Tn>

返回值类型 函数名（参数列表）{}

cpp 复制代码 
template<typename T>
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}
int main()
{
	int i = 1, j = 2;
	Swap(i, j);

	char c1 = 'z', c2 = 'a';
	Swap(c1, c2);
	return 0;
}

注意：typename是用来定义模板参数关键字，也可以使用class（切记：不能使用struct代替class）。

7.2.3 函数模板原理

函数模板是一个蓝图，它本身并不是函数，是编译器使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复事情交给了编译器。

在编译器编译阶段 ，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数 以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

7.2.4 函数模板的实例化

用不同类型的参数使用函数模板时 ，称为函数模板的实例化 。模板参数实例化分为：隐式实例化 和显式实例化。

1.隐式实例化：让编译器根据实参推演模板参数的实际类型。

2.显式实例化：在函数名后的<>中指定模板参数的实际类型。如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

cpp 复制代码 
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
template<class T>
void Func(size_t n)
{
	T* ptr = new T[n];
	cout << ptr << endl;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.1, d2 = 20.1;
	//隐式实例化（通过实参类型，推到模板参数类型）
	cout << Add(a1, a2) << endl;
	cout << Add(d1, d2) << endl;

	cout << Add((double)a1, d1) << endl;
	cout << Add(a1, (int)d1) << endl;

	//显式实例化
	cout << Add<int>(a1, d1) << endl;
	cout << Add<double>(a1, d1) << endl;
	//以下必须用显式实例化
	Func<int>(10);
	return 0;
}

7.2.5 模板参数的匹配原则

  1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。
cpp 复制代码 
//专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}
//通用的加法函数
template<class T>
T Add(T left, T right)
{
	return left + right;
}
int main()
{
	int i = 1, j = 2;
	cout<<Add(i, j)<<endl;//有现成的先调用现成的
	//强制调用模板
	cout << Add<int>(i,j) << endl;
	double c = 1.1, d = 2.2;
	Add(c, d);//没现成的用模板实例化一个
	return 0;
}
  1. 对于非模板函数和同名函数模板，如果其他条件都相同，在调用时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板。
cpp 复制代码 
//专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}

//通用加法函数
template<typename T1,typename T2>
T1 Add(const T1& left, const T2& right)
{
	return left + right;
}
int main()
{
	cout << Add(1, 2) << endl;//调用上面现成的Add函数
	cout << Add(1, 2.1) << endl;//调用上面的通用加法函数
	return 0;
}
  1. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。

7.3 类模板

7.3.1类模板的定义格式

cpp 复制代码 
//类模板
//模板不支持声明和定义分离.h和.cpp
template<class T>
class Stack {
public:
	Stack(size_t n = 4)
		:_a(new T[n])
		,_top(0)
		,_capacity(n)
	{}
	void Push(const T& x)
	{
		//扩容
		//...
		_a[_top++] = x;
	}
private:
	T* _a;
	size_t _top;
	size_t _capacity;
};
int main()
{
	//类模板都必须是显式实例化
	Stack<int> st1;     //存int
	st1.Push(1);
	Stack<double> st2;  //存double
	st2.Push(2.1);
	return 0;
}

7.3.2类模板的实例化

cpp 复制代码 
template<class T=int>
class A {
public:
	T x1;
	T x2;
};

template<class T1 ,class T2=int>//半缺省参数必须从右往左缺省
class B {
public:
	T1 x1;
	T2 x2;
};
int main()
{
	A<int> aa1;
	A<> aa2;//如果不传就用缺省值
	A<double> aa1;

	B<double, int> bb1;
	B<double> bb2;
	return 0;
}

以上就是我们今天的内容，下节，我将正式进入"STL"这个板块，觉得有帮助的朋友们可以一键三连喔~互三必回！

相关推荐
朝朝辞暮i1 小时前
C++ 第 32 课：main()、rclcpp::init()、spin()、shutdown()
开发语言·c++·算法
汉克老师1 小时前
GESP2026年9月认证C++一级( 第三部分编程题（1、新龟兔赛跑））精讲
c++·gesp·小学生·学c++编程
可乐鸡翅yeah_1 小时前
HLS 分片过期清理，直播旧 TS 分片磁盘爆满问题处理
java·后端·spring·m3u8·m3u8在线·音视频在线播放
沫璃染墨2 小时前
《从零入门Linux系统篇（五十七）：线程篇·十——生产者消费者模型进阶：从环形缓冲区到POSIX信号量》
linux·运维·服务器·开发语言·c++·系统架构·信号处理
专业程序开发源2 小时前
SSM校园拍摄交流服务平台36936-计算机课程设计、毕业设计
java·spring boot·后端·python·elasticsearch·php·课程设计
用户094248568032 小时前
第23章：OpenJDK逃逸分析、标量替换与锁优化
java·jvm
wuminyu2 小时前
LockStack在虚拟线程Mount和Unmount拷贝过程剖析
java·linux·c语言·jvm·c++
樱花落木兰2 小时前
分布式登录实战：Session 会话共享改造，Redis 存储用户登录状态
java·javascript·数据库·redis·分布式·缓存
HAHAXX82 小时前
电商RPA批量上架通用方案：一套流程如何同时跑通拼多多、抖店、淘宝和跨境平台
java·运维·rpa
热门推荐
01历年考研数学一、数学二、数学三真题试卷及答案PDF02国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）03如何新建文件夹？ 电脑新建文件夹的4种方法04Telegram APK 下载安装完整指南 — 2026年最新05GitHub 镜像站点06蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接07Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）082026 爱知・名古屋亚运会怎么看？直播平台+赛程安排分享09微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新10给AI一张“业务概念地图“：本体如何从哲学走向企业智能