C++模板初阶 | 内存管理
Posted Corwttaml
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++模板初阶 | 内存管理相关的知识，希望对你有一定的参考价值。
文章目录
🎪 模板初阶
🚀1.泛型编程
当我们实现一个简单的swap交换函数的时候，假如说有int，double，char类型需要我们交换，我们可以使用函数重载实现，那么我们的代码是不是会很冗余.
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;
//...
使用函数重载虽然可以实现，但是有一下几个不好的地方：
- 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数
- 代码的可维护性比较低，一个出错可能所有的重载均出错
- 相同逻辑实现导致代码冗余
那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？
如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件(即生成具体类型的代码），那将会节省许多头发。巧的是前人早已将树栽好，我们只需在此乘凉。
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
🚀2.函数模板
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
语法：
template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表)
template<typename T>
void Swap(T& left, T& right)
T temp = left;
left = right;
right = temp;
注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)，且定义一个模板只作用于紧挨着的函数或者类，并不是定义一个作用全局
函数模板的原理
那么如何解决上面的问题呢？大家都知道，瓦特改良蒸汽机，人类开始了工业革命，解放了生产力。机器生产淘汰掉了很多手工产品。本质是什么，重复的工作交给了机器去完成。有人给出了论调：懒人创造世界
函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用，比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此
函数模板的实例化
用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化
- 隐式实例化：让编译器根据实参推演模板参数的实际类型
template<class T>
T Add(const T& left, const T& right)
return left + right;
template<class T>
T Add(const T& left, const T& right)
return left + right;
int main()
int a1 = 10, a2 = 20;
double d1 = 10.0, d2 = 20.0;
Add(a1, a2);
Add(d1, d2);
//此语句能通过编译吗？
Add(a1, d1);
// 此时有两种处理方式：. 用户自己来强制转化 2. 使用显式实例化
Add(a1, (int)d1);
return 0;
该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T， 编译器无法确定此处到底该将T确定为int 或者 double类型而报错
注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅
此时怎么处理呢？
- 强制类型转换：程序员自己强制类型转换成一个类型
//强制类型转换
Add(a1, (int)d1)
- 显式实例化：在函数名后的<>中指定模板参数的实际类型
// 显式实例化
Add<int>(a, b);
如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错
模板参数的匹配原则
1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
// 专门处理int的加法函数
int Add(int left, int right)
return left + right;
// 通用加法函数
template<class T>
T Add(T left, T right)
return left + right;
void Test()
Add(1, 2); // 与非模板函数匹配，编译器不需要特化
Add<int>(1, 2); // 调用编译器特化的Add版本
2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板
// 专门处理int的加法函数
int Add(int left, int right)
return left + right;
// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
return left + right;
void Test()
cout << Add(1, 2) << endl;// 与非函数模板类型完全匹配，不需要函数模板实例化
cout << Add(1, 2.1) << endl;// 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
int main()
Test();
return 0;
3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
区分：类模板是一个类家族，模板类是通过类模板实例化的具体类
🚀3.类模板
语法格式：
template<class T1, class T2, ..., class Tn>
class 类模板名
// 类内成员定义
;
泛型动态顺序表
// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
template<class T>
class Vector
public:
Vector(size_t capacity = 10)
: _pData(new T[capacity])
, _size(0)
, _capacity(capacity)
// 在类中声明，在类外定义。
~Vector();
//void PushBack(const T& data);
//void PopBack();
size_t Size() return _size;
T& operator[](size_t pos)
assert(pos < _size);
return _pData[pos];
private:
T* _pData;
size_t _size;
size_t _capacity;
;
// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
//类内声明类外定义(加上模板参数),类模板声明和定义尽量不分开(会报错)
template <class T>
Vector<T>::~Vector()
if (_pData)
delete[] _pData;
_size = _capacity = 0;
类模板的实例化
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类
// Vector类名，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;
🎪 内存管理
🚀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";
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);
答案：
注意：
- 栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
- 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（Linux）
- 堆用于程序运行时动态内存分配，堆是可以上增长的。
- 数据段–存储全局数据和静态数据。
- 代码段–可执行的代码/只读常量
注意：对于栈来讲，生长方向是向下的，也就是向着内存地址减小的方向；对于堆来讲，它的生长方向是向上的，是向着内存地址增加的方向增长
面试题：设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？
C c;
void main()
A*pa=new A();
B b;
static D d;
delete pa;
分析:首先手动释放pa， 所以会先调用A的析构函数，其次C B D的构造顺序为 C D B，因为先构造全局对象，在构造局部静态对象，最后才构造普通对象，然而析构对象的顺序是完全按照构造的相反顺序进行的，所以答案为 A B D C
🚀2.C/C++内存管理
⭐2.1 C语言内存管理
我们知道C语言中动态内存管理方式：malloc/calloc/realloc/free
void Test()
int* p1 = (int*)malloc(sizeof(int));
free(p1);
int* p2 = (int*)calloc(4, sizeof(int));
int* p3 = (int*)realloc(p2, sizeof(int) * 10);
// 这里需要free(p2)吗？
//不需要因为realloc扩容的方式要么是原地扩容，要么是异地扩容
//p2要么是p3的拷贝，要么被realloc函数free掉，所以不需要主动free
free(p3);
面试题：1.malloc/calloc/realloc的区别？
-
malloc函数
malloc函数用于在堆上分配指定大小的内存空间，并返回该空间的起始地址。其函数原型为：void* malloc(size_t size);
其中，size_t是一个无符号整数类型，表示要分配的内存大小。如果分配成功，则返回一个指向起始地址的void型指针；否则返回NULL。 -
calloc函数
calloc函数与malloc函数类似，也用于在堆上分配内存空间，但与malloc不同的是，它会在分配的内存空间中将每个字节都初始化为0。其函数原型为：
void* calloc(size_t nmemb, size_t size);
其中，nmemb表示要分配的元素个数，size表示每个元素的大小。如果分配成功，则返回一个指向起始地址的void型指针；否则返回NULL。 -
realloc函数
realloc函数用于重新分配已经分配的内存空间。其函数原型为：void* realloc(void* ptr, size_t size);
其中，ptr是指向已经分配的内存空间的指针，size表示重新分配的大小。如果重新分配成功，则返回一个指向起始地址的void型指针；否则返回NULL。
需要注意的是，如果ptr为NULL，则realloc的效果就相当于malloc；如果size为0，则realloc的效果就相当于free。另外，由于realloc函数需要复制已有的内存数据，所以其执行效率可能会比较低。
2.malloc的实现原理：
-
内存池初始化
首先，malloc() 会通过系统调用向操作系统请求一块足够大的内存空间，然后将其划分成一块一块大小相等的内存块，这些内存块被组织成链表的形式，这个链表被称为内存池（memory pool）。 -
内存分配
当程序调用 malloc() 请求内存时，malloc() 会遍历内存池，寻找第一个可用的内存块，然后将其标记为已占用，并返回其起始地址给程序。如果内存池中没有可用的内存块，malloc() 就会调用操作系统的系统调用请求更多的内存。 -
内存释放
当程序使用 free() 函数释放已分配的内存时，free() 会将内存块标记为可用，然后将其加入内存池中，以备后续的内存分配使用。 -
内存整理
由于程序中频繁地分配和释放内存，内存池中可能会存在很多被标记为可用的内存块，这些内存块不太可能再被程序使用，但是它们却占用了宝贵的内存空间。为了解决这个问题，malloc() 会定期进行内存整理，将那些不再被使用的内存块合并成更大的内存块，并释放多余的内存，以便程序更好地利用内存空间。
⭐2.2 C++内存管理方式
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
操作内置类型
void Test()
// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请10个int类型的空间
int* ptr6 = new int[3];
delete ptr4;
delete ptr5;
delete[] ptr6;
注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]，注意：匹配起来使用，否则在某些地方会出现问题（如内存泄露）
如以下代码：
int* p5 = new int[10];
free(p5);
运行时程序会直接崩溃，因为对于new[]操作符，和编译器机制有关,VS中对于自定义类型new[]的数组会在头上开4个字节存储数组元素个数(了解自己要调多少次析构函数)而delete会往前找指针位置(回偏)，而此处使用free就是因为指针释放的位置不对，才会引起程序奔溃.
操作自定义类型
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;
// 内置类型是几乎是一样的
int* p3 = (int*)malloc(sizeof(int)); // C
int* p4 = new int;
free(p3);
delete p4;
A* p5 = (A*)malloc(sizeof(A) * 10);
A* p6 = new A[10];
free(p5);
delete[] p6;
return 0;
注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会
🚀3.new & delete的实现原理
new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
// try to allocate size bytes
void* 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_FINALLY
return;
通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
- 内置类型
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL
- 自定义类型
- new的原理
调用operator new函数申请空间，在申请的空间上执行构造函数，完成对象的构造- delete的原理
在空间上执行析构函数，完成对象中资源的清理工作调用operator delete函数释放对象的空间- new T[N]的原理
调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请，在申请的空间上执行N次构造函数- delete[]的原理
在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理，调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间
🚀4.定位new表达式
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象
语法：new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化
int main()
char* p = new char[100];
delete p;
return 0;
class A
public:
A(int a = 0)
: _a(a)
cout << "A():" << this << endl;
~A()
cout << "~A():" << this << endl;
private:
int _a;
;
// 定位new/placement new
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));
//将_a初始化为10
new(p2)A(10);
p2->~A();
operator delete(p2);
return 0;
🚀5.C/C++内存管理常见面试题
我们来几道面试题开开胃.
⭐5.1 malloc/free和new/delete的区别
malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地方是：
- malloc和free是函数，new和delete是操作符
- malloc申请的空间不会初始化，new可以初始化
- malloc申请空间时，需要手动计算空间大小并传递，new 只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可
- malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型*
- malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
- 申请自定义类型对象时，malloc/f
C++初阶C&C++内存管理
目录
四，operator new与operator delete函数
一，C/C++内存分布
1，这几个区域，堆是很大的
2，从图中看，栈和堆差不多，实际栈很小，一般只有8M（LINUX下），所以递归调用深度太深，会导致栈溢出
3，数据段和代码段也不是很大，因为没有多少数据
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); }
二，C语言中动态内存管理方式
malloc/calloc/realloc的区别？
calloc等价于malloc+memset(0) 开空间+初始化
realloc是对malloc或calloc的空间进行扩容
三，C++内存管理方式
class A { public: A(int a = 0) :_a(a) { cout << "A()" << endl; } ~A() { cout << "~A" << endl; } private: int _a; }; int main() { int* p1 = (int*)malloc(sizeof(int)); free(p1); int* p2 = new int; delete p2; A* p3 = (A*)malloc(sizeof(A)); free(p3); A*(p4) = new A; delete p4; return 0; }对于自定义类型，new/delete不仅仅会开空间/释放空间，还会调用构造函数和析构函数，而malloc与free不会
四，operator new与operator delete函数
new T——》1：申请空间->operator new （如果申请空间失败了，抛异常） 2：构造函数
operator new就是对malloc封装-》申请内存失败了，抛异常
delete T——》1：调用T的析构函数 2：operator delete（p）
class Stack { public: Stack(int capacity = 4) :_a(new int[capacity]) , _size(0) , _capacity(capacity) { cout << "Stack(int capacity = 4)" << endl; } ~Stack() { delete[] _a; _size = _capacity = 0; cout << "~Stack()" << endl; } }; int main() { Stack st; Stack* ps = new Stack; delete ps; return 0; }
五，常见面试题
malloc/free和new/delete的区别：
特点和用法：
1. malloc和free是函数，new和delete是操作符
2.malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可
3. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
底层原理区别：
申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理
处理错误的方式：
malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
内存泄露：
int main() { char* p = new char[1024 * 1024 * 1024]; return 0; }上面程序存在内存泄露，一次泄露1G，但是多次泄露，对我们系统好像也没什么影响
一个进程正常结束后，会把映射的内存都会释放掉，所以上面的程序，我们没有主动释放，但是进程结束也释放，那么内存泄露好像也没啥事？因为进程正常结束，都会释放。
其实不是：
第一：进程没有正常结束，僵尸进程，就可能存在一些资源没释放。
第二：长期运行的服务器程序，长期运行，只有升级的时候才会停
内存泄露会导致可用内存越来越少，程序越来越慢，甚至挂掉——事故。
第三：物联网设备：扫地机器人等，内存很小，也会经不起内存泄露的折腾。
C++需要主动释放内存，java不需要主动释放内存，java后台有垃圾回收器，接管了内存释放
如何预防内存泄露：
1，智能指针
2，内存泄露检测工具：内存泄露检测工具
以上是关于C++模板初阶 | 内存管理的主要内容，如果未能解决你的问题，请参考以下文章
C++初阶第七篇——C/C++的内存管理（C/C++动态内存分布+new和delete的用法和实现原理)
C++初阶：内存管理C/C++内存分布及管理方式 | new/delete实现原理及operator new和operator delete函数
C++初阶：内存管理C/C++内存分布及管理方式 | new/delete实现原理及operator new和operator delete函数
