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);
}

/*

. 选择题：
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？__c__
staticGlobalVar在哪里？__c__
staticVar在哪里？__c__
localVar在哪里？__a__
num1 在哪里？___a_
char2在哪里？___a_
*char2在哪里？_a__
pChar3在哪里？__a__
*pChar3在哪里？__*pChar3指向的是abcd，abcd在常量区   D__
ptr1在哪里？__a__
*ptr1在哪里？__b__//malloc在堆上

*/
/*
全局数据和静态数据都在静态区
局部静态变量也是存在于静态区的

*/

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

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

总结

• 使用 malloc 时，内存内容是未初始化的；

• 使用 calloc 时，内存内容会被初始化为零；

• 使用 realloc 可以调整已分配内存的大小，可以根据需要扩展或缩小。

3.C++内存管理方式

new/delete操作内置类型

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

new在C++里面是个操作符/运算符

如果想申请一个整数，就直接new int

如果想初始化的话，这么写 new int(3)

如果想new多个int的话，后面跟方括号

void Test()
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;
	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);
	// 动态申请10个int类型的空间
	int* ptr6 = new int[3];

	//如果是多个数组中的对象要初始化的话
	int* ptr7 = new int[3] {1, 2, 3};

	delete ptr4;
	delete ptr5;
	delete[] ptr6;
}

new和delete操作自定义类型

注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]，注意：匹配起来使用。

内置类型用malloc还是new都是可以的，但是自定义类型就不一样了

自定义类型推荐使用new

malloc只会申请空间，但是new不仅会申请空间，还会调用构造函数

free只会释放空间，但是delete不仅会释放空间还可以调用析构函数

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};

struct ListNode//链表
{
	int _val;
	ListNode* _next;
	ListNode(int val)
		:_val(val)
		, _next(nullptr)
	{

	}
};
int main()
{
	//只申请空间
	A* p1 = (A*)malloc(sizeof(A));

	//用new就方便很多了
	//申请空间+构造函数
	A* p2 = new A(1);

	//只释放空间
	free(p1);

	//释放空间+析构函数
	delete p2;

	A* p6 = new A[10];//申请10个对象的空间
	//回调用10次构造函数
	delete[] p6;

	A aa1(1);
	A aa2(1);

	//A* p7 = new A[10]{ aa1,aa2 };
	A* p7 = new A[10]  {1,2,3};//直接使用隐式类型转换
	delete[] p7;
	 
	//在C语言的链表中我们通常需要写个buynode来申请一个节点
	//但是我们在C++中就不用了，我们直接new就行了
	ListNode* n1 = new ListNode(1);//申请空间并且调用ListNode的构造函数
	ListNode* n2 = new ListNode(2);
	ListNode* n3 = new ListNode(3);
	ListNode* n4 = new ListNode(4);

	n1->_next = n2;
	n2->_next = n3;
	n3->_next = n4;


	return 0;
}
//在一个类中一定要提供默认构造，不然就会出现很多的问题了

我们通过C++进行链表节点申请的时候我们可以直接通过new来进行申请空间和调用构造函数

就不用像c语言那样来写个函数进行节点的申请和初始化操作了

4.operator new与operator delete函数（重要点进行讲解）

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

operator new实际上是对malloc的一个封装

malloc失败之后返回一个空指针

operator new申请失败后会抛异常

operator new底层封装malloc

operator delete是和operator new进行配对的

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

5.new和delete的实现原理

内置类型

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

自定义类型

•new的原理

1. 调用operator new函数申请空间

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

•delete的原理

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

直接这样写，operator new和malloc的区别就是operator new失败了会抛异常，没有返回值

但这个不会调用构造函数，用法和malloc相似的

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

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

用格式：new (place_address) type或者new (place_address) type(initializer-list)

place_address必须是一个指针，initializer-list是类型的初始化列表

使用场景：定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

对p1指向的那块空间调用构造函数进行初始化操作

构造函数不支持显示调用，析构函数支持显示调用的

不要忘记释放，不要交错释放

7.malloc/free和new/delete的区别

8.泛型编程

//C++支持函数重载，允许函数名重复
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;
}

9.函数模版

模版概念

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

函数模版格式

template<typename T1, typename T2,…,typename Tn>返回值类型 函数名(参数列表){}

template英文翻译就是模版的意思

下面是一个交换函数的模版，可以对不同的类型进行一个交换的操作

template<typename T>
void Swap(T& left, T& right)//针对广泛的类型
{
	T temp = left;
	left = right;
	right = temp;
}
int main()
{
	int x = 0, y = 1;
	double m = 1.1, n = 2.2;
	//通过模版就很方便了
	//调用的其实还是两个函数
	Swap(x, y);
	Swap(m, n);

	return 0;
}

语法上面我们需要声明这个模版参数的类型template

模版的原理

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

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

函数模板的实例化

编译器通过模版生成对应的函数叫做实例化操作

实例化分为两种，一种叫做隐式实例化，一种叫做显式实例化

如果我们传的是两个类型不一样的数据的话是会报错的

，但是我们可以通过增加多个模版参数来进行不同类型数据的交换的

隐式实例化

template<typename T>//传递的是类型
void Swap(T& left, T& right)//定义的是对象
{
	T temp = left;
	left = right;
	right = temp;
}

template<class T1, class T2>//传递的是类型
void Swap(T1& left, T2& right)//定义的是对象
{
	T temp = left;
	left = right;
	right = temp;
}
int main()
{
	int x = 0, y = 1;
	double m = 1.1, n = 2.2;
	//通过模版就很方便了
	//调用的其实还是两个函数
	Swap(x, y);
	Swap(m, n);

	Swap(m, y);

	return 0;
}
//这两个实例化生成的函数构成重载了

像这种的话，我们如果传的是两种类型的数据的话，按照这个模版来，编译器是会报错的

但是我们是可以通过这个两个模版来解决这个问题的

还有一个方法，可以在传数据的时候将其中一个数据进行强制转换的操作

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.1, d2 = 20.1;
	Add(a1, a2);
	Add(d1, d2);

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

	return 0;
}

显示实例化

在函数名和函数参数中间加上尖括号，括号之内写上要转换的类型

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.1, d2 = 20.1;

	//自动推导类型  隐式实例化
	Add(a1, a2);
	Add(d1, d2);

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

	//在函数名和参数列表中间加上尖括号
	//这个叫做显示实例化
	cout <<  Add<int>(a1,d1) << endl;//20
	cout << Add<double>(a1, d1) << endl;//20.1


	return 0;
}

隐式实例化就是编译器进行一个自动推导，查看里面的数据类型

但是我们的显示实例化操作，我们直接显示的写出了我们要参与的数据的类型是什么

我们不知道传的类型是什么参数，对于这种的话我们就可以在传参的时候进行显式实例化操作了

编译器推不出来我们的数据是什么类型的，所以我们要显示的写出来这个参数的类型

如果模版函数和普通函数都存在的话我们是直接选择使用这个普通函数的，因为模版的话我们的编译器还要去推导这个T的类型，很麻烦，我们直接用普通的就行了

 int Add(int  left, int right)
{
	return left + right;
}


template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}

int main()
{
	Add(1, 2);
	return 0;
}

//我们这里有两个Add函数，那么调用的时候会先调用谁呢？
//模版和普通函数是可以同时存在的，但是我们是不知道会调用哪一个函数

//用模版其实比用普通函数更加麻烦的，因为编译器是需要对T进行一个推导的过程的
//有现成的就用现成的，就用普通函数

模版参数的匹配规则

1.一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

2.对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

不同类型调用不同的函数或者模版

int Add(int  left, int right)
{
	return left + right;
}


template<class T>
T Add(const T& left, const T& right)
{
	return (left + right)*5;
}


template<class T1,class T2>
T1 Add( T1 left,  T2 right)
{
	return (left + right) * 10;
}

int main()
{
	cout << Add(1, 2) << endl;//调用普通函数
	//现在我们不想调用这个普通函数，我们想调用模版我们怎么解决呢？
	//我们显示实例化一下就行了
	//我们在这里显示实例化了，就是指明了编译器一定要使用模版
	cout << Add<int>(1, 2) << endl;//调用第一个模版
	cout << Add(1, 2) << endl;//调用第一个模版

	cout << Add(1, 2.2) << endl;//调用第二个模版


	return 0;
}

对于我们这里使用的Swap这个交换例子，我们以后直接使用swap进行交换操作，这个函数是已经在库里面存在了

10.类模版

template<class T1, class T2>
class 类模板名
{
	// 类内成员定义
};

#include<iostream>
using namespace std;

using STDataType = int;

// 类模版
//template<typename T>
class Stack
{
	
public :
	Stack(size_t capacity = 4)
	{
		_array = new STDataType[capacity];
		_capacity = capacity;
		_size = 0;
	} 
private:
	STDataType* _array;
	size_t _capacity;
	size_t _size;
};

int main()
{
	//现在我们想往两个栈分别存入不同类型的数据
	//如果使用我们的这个using STDataType = int;是不能解决问题的

	Stack st1;//存int
	Stack st2;//存double

	return 0;
}

// 类模版
template<typename T>
class Stack
{

public:
	Stack(size_t capacity = 4)
	{
		_array = new T[capacity];
		_capacity = capacity;
		_size = 0;
	}
private:
	T* _array;
	size_t _capacity;
	size_t _size;
};

int main()
{
	//现在我们想往两个栈分别存入不同类型的数据
	//如果使用我们的这个using STDataType = int;是不能解决问题的

	//我们的类模版是不能隐式实例化操作的
	//只能显示实例化操作

	//实例化生成对应的类，这里是两个不同的类型
	Stack<int> st1;//存int
	Stack<double> st2;//存double

	return 0;
}

// 类模版
template<typename T>
class Stack
{

public:
	Stack(size_t capacity = 4)
	{
		_array = new T[capacity];
		_capacity = capacity;
		_size = 0;
	}
	
	void Push(const T& data);
private:
	T* _array;
	size_t _capacity;
	size_t _size;
};
void Stack::Push(const T& data)
{
	// 扩容
	_array[_size] = data;
	++_size;
}

// 类模版
template<typename T>
class Stack
{

public:
	Stack(size_t capacity = 4)
	{
		_array = new T[capacity];
		_capacity = capacity;
		_size = 0;
	}
	
	void Push(const T& data);
private:
	T* _array;
	size_t _capacity;
	size_t _size;
};
template<typename T>
void Stack<T>::Push(const T& data)
{
	// 扩容
	_array[_size] = data;
	++_size;
}

// Stack是类名，Stack<int>才是类型
Stack<int> st1; // int
Stack<double> st2; // double

11.什么是STL

12.STL的版本

13.STL的六大组件

14.STL的重要性

15.如何学习STL