内存管理与模板
总引
在学习完类与对象之后，我们的C++学习迎来了新的篇章：内存管理与模板。在这篇中我们会学习C++中代替malloc和realloc的两个操作符new和delete，以及它们具体的使用场景与底层逻辑。也会学习C++中的模板来让我们的对象创建变得更为方便与灵活。
一.内存管理
在C语言中我们想要申请空间会使用malloc，realloc，calloc等函数来申请，但是在C++里我们学习了自定义类型，当我们想要为自定义类型申请空间时以上的函数则会显得捉襟见肘，所以C++定义新的操作符new和delte。
1.1new和delete的定义
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因
此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
#include <iostream>
using namespace std;
#include <malloc.h>
int main()
{
//C语言的内存开辟方式
//申请空间
//申请一个类型为int的空间
int* p1 = (int*)malloc(sizeof(int));
//将p1扩容为2个类型为int的空间
int* p2 = (int*)realloc(p1, sizeof(int) * 2);
//申请10个类型为int的空间并初始化为4
int* p3 = (int*)calloc(4, sizeof(int) * 10);
//释放空间
//free(p1) //p1不需要free
free(p2);
free(p3);
//C++的内存开辟方式
//申请空间
//申请一个类型为int的空间
int* p4 = new int;
//申请一个类型为int的空间并初始化为1
int* p5 = new int(1);
//申请10个类型为int的空间并初始化为4
int* p6 = new int[10]{ 4,4,4,4,4,4,4,4,4,4 };
//释放空间
delete p4;
//释放不止申请了一个空间时
delete[] p5;
delete[] p6;
return 0;
}
注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用 new[]和delete[]，注意：匹配起来使用。
1.2new和delete操作自定义类型
在面对内置类型时，new和delete没法展现出它们的优势从而让我们觉得它和malloc也差不了多少，但是在面临自定义类型时new和delete的才能大展雄风。
class A
{
public:
A(int date = 0)
:_date(date)
{
cout << "A(int date)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _date;
};
int main()
{
//C语言
A* a1 = (A*)malloc(sizeof(A));
//C++
A* a2 = new A(1);
free(a1);
delete a2;
//new和delete在面临自定义类型时最大的区别就是
//new会调用构造函数，delete会调用析构函数。
return 0;
}
注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与 free不会。
1.3operator new和operator 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;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)
通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果
malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
而对于抛异常这个行为可以通过下面的代码来一窥一二：
void Func()
{
int* p1 = new int[100000000];
//当用new创建的内存过大时，我们用调试可以发现编译器不会进行下面的流插入
//而是直接跳转到catch里的流插入中，有点类似与C语言中的goto。
cout << "hello world" << endl;
}
int main()
{
try
{
Func();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}
1.4new和delete的工作原理
1.内置类型：
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：
new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
2.自定义类型：
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来释 放空间
1.5new和delete的区别
malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地方是：
- malloc和free是函数，new和delete是操作符
- malloc申请的空间不会初始化，new可以初始化
- malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可
- malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
- malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需
要捕获异常 - 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new
在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理
二.模板
在C语言中我们会经常用到一些可能仅仅只是参数的类型不同的函数，那时我们逼不得已只能为这些函数取不同的名字。
2.1 泛型编程
而在C++中我们学习了函数重载的概念，所以我们可以用相同的函数名不同的参数类型来让使用变得方便。
void Swap(int& left, int& right)
{
int tmp = left;
left = right;
right = tmp;
}
void Swap(double& left, double& right)
{
double tmp = left;
left = right;
right = tmp;
}
void Swap(char& left, char& right)
{
char tmp = left;
left = right;
right = tmp;
}
int main()
{
int a = 0;
int b = 1;
Swap(a, b);
double c = 1.1;
double d = 2.1;
Swap(c, d);
char e = 'e';
char f = 'f';
Swap(e, f);
cout << a << ' ' << b << endl;
cout << c << ' ' << d << endl;
cout << e << ' ' << f << endl;
return 0;
}
但是我们仍然需要将这些函数的函数体一个一个的写出来，这不禁还是让代码的可读性下降，那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？即模板。
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
2.2模板的概念
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定 类型版本。
template <typename T>
void Swap(T& left, T& right)
{
T tmp = left;
left = right;
right = tmp;
}
注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)
2.3模板的原理
函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。
2.4模板类型的实例化
用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。
1.隐式实例化：让编译器根据实参推演模板参数的实际类型
template <typename T>
T Add(T& a, T& b)
{
return a + b;
}
int main()
{
int a = 1;
int b = 2;
cout << Add(a,b) << endl;
double c = 2.1, d = 3.1;
cout << Add(c, d) << endl;
//Add(a,c)
//这样的写法会报错，因为在编译过程中，当编译器看到模板的实例化后
//会推演其实参类型，看到a为int类型就会将T推演成int，看到c为double就会将T推演成double
//但是模板参数T只有一个，所以编译器会因为分不清T的类型而出错。
//解决方法:使用显式实例化
return 0;
}
2.显式实例化:在函数名后的<>中指定模板参数的实际类型
template <typename T>
T Add(T& a, T& b)
{
return a + b;
}
int main()
{
int a = 1;
double c = 1.1;
Add<int>(a, c);//显式实例化
return 0;
}
注意：如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。
2.5模板参数的匹配
1.一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
//专门处理int类型加法的函数
int Add(int a, int b)
{
return a + b;
}
//通用的模板函数
template <typename T>
T Add(T& a, T& b)
{
return a + b;
}
int main()
{
int a = 1;
int b = 1;
Add(a, b);//与非模板函数匹配，使用非模板函数
Add<int>(a, b);//调用编译器特化的Add版本
return 0;
}
2.对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板
//专门处理int类型加法的函数
int Add(int a, int b)
{
return a + b;
}
//通用的模板函数
template <typename T1 , typename T2>
T1 Add(T1& a, T2& b)
{
return a + b;
}
int main()
{
Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}
3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
2.3类模板
//template<class T1, class T2, ..., class Tn>
//class 类模板名
//{
// 类内成员定义
//};
template <class T>
class Stack
{
public:
Stack(int capacity = 4)
{
_array = (T*)malloc(sizeof(T) * capacity);
if (_array == nullptr)
{
cout << "malloc fail" << endl;
exit(-1);
}
_capacity = capacity;
_size = 0;
}
Stack(const T& s)
{
_array = (T*)malloc(sizeof(T) * s._capacity);
if (_array == nullptr)
{
cout << "malloc fail" << endl;
exit(-1);
}
memcpy(_array, s._array, sizeof(T) * s._size);
_capacity = s._capacity;
_size = s._size;
}
void Print()
{
for (int i = 0; i < _size; i++)
{
cout << _array[i] << ' ';
}
cout << endl;
}
~Stack()
{
free(_array);
_capacity = 0;
_size = 0;
}
private:
T* _array;
int _size;
int _capacity;
};
int main()
{
//类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>
//中即可，类模板名字不是真正的类，而实例化的结果才是真正的类
//Stack类名，Stack<int>才是类型
Stack<int> s;
}
总结
在学习了内存管理和模板后，C++前期的知识已经学习的差不多了后面我们将进入STL的学习，这是C++学习中的重中之重。
1026
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
