一、内存管理
1.课件上关于内存分配的题目
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);
}
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. CCCAA ADCDCB
2. 40 5 4 4 4 4
说明
1. 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口
创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段--存储全局数据和静态数据。
5. 代码段--可执行的代码/只读常量
2.malloc/realloc/calloc的区别是什么？
C语言中动态内存管理方式：malloc/calloc/realloc/free
void * malloc(int n);
void *calloc(int n,int size);
void * realloc(void * p,int n);
相同点：
1.都是从堆上申请空间；
2.都需要对返回值判空；
3.都需要用户free释放；
4.返回值类型相同（都是void*）；
5.都需要类型转化；
6.底层实现是一样的，都需要开辟多余的空间，用来维护申请的空间。
不同点：
1.函数名字不同，参数类型不同；
2.calloc函数会对申请空间初始化，并且初始化为0；
3.malloc函数申请空间必须使用memset进行初始化；
4.realloc函数是对已经存在的空间进行调整，当第一个参数传入NULL的时候和malloc函数一样，其调整分为两种请况：
- 调整的空间比原来的大
a.大了一点：多出来的空间小于下面空闲的空间
调整方法：
(1)直接延伸申请空间；
(2)返回空间首地址。
b.打了很多：多出来空间大于下面空闲空间
调整方法：
（1）重新开辟新空间；
（2）将旧空间的内容拷贝到新空间中；
（3）释放旧空间；
（4）返回新空间的首地址。
- 调整的空间比原来的小
调整方法：
（1）将原有空间缩小；
（2）返回旧空间首地址。
用简洁的话表示就是，malloc在堆上开辟空间，calloc与malloc的区别是它会在
开空间之后初始化为0，realloc一般用来扩容，分为本地扩容和异地扩容，如果是本地扩容就不需要释放原来的空间，可以直接在原来的空间的基础上尽心扩容，如果是异地扩容，就会把原来的空间释放掉，另外找一片足够大的空间，返回一个指针。
3. new/malloc，delete/free的区别是什么（这个非常重要）
- 从用法上看，new和delete更加的简单了
- 可以控制初始化，对于自定义类型会自动去调用它的构造函数和析构函数（注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。）
来自牛客校招C++宝典的问题和参考答案：
说说new和malloc的区别，各自底层实现原理。
1. new是操作符，而malloc是函数。
2. new在调用的时候先分配内存，在调用构造函数，释放的时候调用析构函数；而malloc没有构造
数和析构函数。
3. malloc需要给定申请内存的大小，返回的指针需要强转；new会调用构造函数，不用指定内存的
大小，返回指针不用强转。
4. new可以被重载；malloc不行
5. new分配内存更直接和安全。
6. new发生错误抛出异常，malloc返回null
malloc底层实现：当开辟的空间小于 128K 时，调用 brk（）函数；当开辟的空间大于 128K 时，调用
mmap（）。malloc采用的是内存池的管理方式，以减少内存碎片。先申请大块内存作为堆区，然后将
堆区分为多个内存块。当用户申请内存时，直接从堆区分配一块合适的空闲快。采用隐式链表将所有空
闲块，每一个空闲块记录了一个未分配的、连续的内存地址。
new底层实现：关键字new在调用构造函数的时候实际上进行了如下的几个步骤：
1. 创建一个新的对象
2. 将构造函数的作用域赋值给这个新的对象（因此this指向了这个新的对象）
3. 执行构造函数中的代码（为这个新对象添加属性）
4. 返回新对象
来自比特课件的问题和回答：
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.new和new[ ]的底层实现：operator new + 构造函数
operator new 和operator delete函数（重点）
operator new是对malloc的封装，operator delete是对free的封装
/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
失败，尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否
则抛异常。
*/
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来释放空间的。
也就是说new是由operator new + 构造函数组成的，operator new是由malloc实现的
new【n】是由operator new【】和n次构造函数组成的，operator new【】由operator new实现，operator new由malloc实现
其中抛异常是在operator new这一层
同理delete也是一样的
这里我来插入一个知识点：
关于new、new【】，delete，delete【】他们之间的关系
如果new对应的是一个自定义对象，那么new【】就是多个自定义对象，如果你显式地给出了析构函数，operator new【】会在开头位置多出4个字节，用来存一共有多少个对象，比如说
#include <iostream>
using namespace std;
class A
{
public:
A():
_a(0)
{ }
A(int a) :
_a(a)
{ }
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
int main()
{
A* ptr = new A[10];//这里指向的那个空间是44个字节（4+4*10）
delete[]ptr;
return 0;
}
如果对于一个由析构函数的自定义类型，用了new 【】，在释放的时候用delete，这时候会报错，原因是开始释放的位置是错误的。
总结：切记一定要匹配使用。
定位new
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：
new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如
果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。
5.越界和野指针的问题
野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
产生原因：释放内存后指针不及时置空（野指针），依然指向了该内存，那么可能出现非法访问的
错误。这些我们都要注意避免。
避免办法：
（1）初始化置NULL
（2）申请内存后判空
（3）指针释放后置NULL
（4）使用智能指针
释放内存后指针不及时置空（野指针），依然指向了该内存，那么可能出现非法访问的错
误。这些我们都要注意避免。
（1）初始化置NULL
（2）申请内存后判空
（3）指针释放后置NULL
6.内存泄露
1）什么是内存泄漏
什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内
存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对
该段内存的控制，因而造成了内存的浪费。
2）内存泄漏的危害是什么？
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现
内存泄漏会导致响应越来越慢，最终卡死。
3）怎么样避免内存泄漏？
1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：
这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智
能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。
总结一下:
内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄
漏检测工具。
补充知识：
C/C++程序中一般我们关心两种方面的内存泄漏：
- 堆内存泄漏(Heap leak)堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一
块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分
内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
- 系统资源泄漏指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放
掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
在vs下，可以使用windows操作系统提供的_CrtDumpMemoryLeaks() 函数进行简单检测，该
函数只报出了大概泄漏了多少个字节，没有其他更准确的位置信息。
因此写代码时一定要小心，尤其是动态内存操作时，一定要记着释放。但有些情况下总是防不胜
防，简单的可以采用上述方式快速定位下。如果工程比较大，内存泄漏位置比较多，不太好查时
一般都是借助第三方内存泄漏检测工具处理的。
二、模板
提到模板不得不说起泛型编程（编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。）
如何实现一个通用的交换函数呢？
使用函数重载虽然可以实现，但是有一下几个不好的地方：
- 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函
数 - 代码的可维护性比较低，一个出错可能所有的重载均出错
那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？
于是，正式提出模板这个概念
1.语法格式
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定
类型版本。
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)
2.模板的原理
函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供
调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然
后产生一份专门处理double类型的代码，对于字符类型也是如此.
用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。
- 隐式实例化：让编译器根据实参推演模板参数的实际类型
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);
/*
该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，
编译器无法确定此处到底该将T确定为int 或者 double类型而报错
注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅
Add(a1, d1);
*/
// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
Add(a, (int)d);
return 0;
}
- 显式实例化：在函数名后的<>中指定模板参数的实际类型
int main(void)
{
int a = 10;
double b = 20.0;
// 显式实例化
Add<int>(a, b);
return 0;
}
模板参数的匹配原则
- 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
- 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板
- 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
类模板的实例化
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>
中即可，类模板名字不是真正的类，而实例化的结果才是真正的类
比如：vector<int>v;