【1】泛型编程

一.为啥要需要模板

杜绝复制,提高效率：把数据类型抽象出来，在定义的时候通过<>传递进来，这样子只要写一次代码，我可以无限次的叠加；

• 有了模板以后，算法被独立出来了；与数据类型(数据结构) 进行了解耦

template<typename T>
void sort(T data[], size_t count)
{
	for (size_t i = 0; i < count - 1; i++)
	{
		for (size_t j = 0; j < count; j++)
		{
			if (data[i] < data[j]) {
				T tmp = data[i];
				data[i] = data[j];
				data[j] = tmp;
			}
		}
	}
}

int main(){
	int data1[5]{ 1,2,3,4,5 };
	float data2[5]{ 1.0f,2.0f,3.0f,4.0f,5.0f };
	sort<int>(data1, sizeof(data1) / sizeof(data1[1]));
	sort<float>(data2, sizeof(data2) / sizeof(data2[1]));
}

二.为啥需要模板容器？

容器：C++定义数组的时候，需要指定数据类型，而容器就是把数据类型抽离出来，剩下的结构构成的东西就叫做容器

int main(){
	int data1[10]{ 1,2,3,4,5 };
	float data2[10]{ 1.0f,2.0f,3.0f,4.0f,5.0f };
	Array<int> data3;
	Array<float> data4;
	data3.SetSize(10);
	for (unsigned i = 0; i < 10; i++)
	{
		data3[i] = data1[i];
		data4[i] = data2[i];
	}
	sort<int>(data3, data3.Size());
}

template<typename T>
class Array {//整数数组→任意类型的数组
public:
	Array() {
		data = NULL;
		size = 0;
	};
	~Array() {
		if (data != NULL) {
			delete[] data;
			data = NULL;
		}
	};
	void SetSize(size_t size) {
		if (this->size >= size) return;
		if (data == NULL) {
			data = new int[size];
			this->size = size;
			return;
		}
		int* temp = new int[size];
		memset(temp, 0, size * sizeof(int));
		memcpy(temp, data, this->size * sizeof(int));//data → temp
		int* p = data;
		data = temp;// temp → data
		delete[] p;
		this->size = size;
	};
	int& operator[](unsigned index) {
		if (index > size)throw "访问越界!";
		return data[index];
	};
	operator int* () {
		return data;
	};
	size_t Size() const {
		return size;
	};
private:
	int* data;
	size_t size;
};

三.为啥需要迭代器

1.使NODE不用暴露在外面，可以设置为私有的结构体，避免了用户把头节点置空这种危险性动作（从设计上杜绝了这种行为）
2.隐藏了链表内部的细节，由迭代器来做媒介，这样子就可以进行链表的读和写

int main(){
	List<int>::iterator it = data5.begin();
	for (; it != data5.end(); ++it)
	{
		cout << *it << endl;
		*it += 10;
	}
}

template<typename T>
class List //单链表
{
private:
	typedef struct ListNode {
		T data;
		ListNode* next;
	}NODE;
public://迭代器
	class iterator {
	public:
		explicit iterator(NODE* n) {
			pNode = n;
		}
		T& operator*() {
			return pNode->data;
		}
		iterator& operator=(const iterator& it) {
			pNode = it.Node;
		}
		iterator& operator++() {
			pNode = pNode->next;
			return *this;
		}
		bool operator==(const iterator& it) {
			return pNode == it.pNode;
		}
		bool operator!=(const iterator& it) {
			return pNode != it.pNode;
		}
	private:
		NODE* pNode;
	};
public:
	List() {
		m_head.next = NULL;
		m_size = 0;
		m_tail = NULL;
	};
	~List() {
		NODE* p = m_head.next;
		while (p != NULL) {

		}
		m_head.next = NULL;
		m_tail = NULL;
		m_size = 0;
	};
	void push_back(const T& data) {
		NODE* p = new NODE;
		p->data = data;
		if (m_tail == NULL) {
			m_head.next = p;
		}
		else {
			m_tail->next = p;
		}
		m_tail = p;
	};
	size_t Size()const { return m_size; };
	iterator begin() {
		return iterator(m_head.next);
	}
	iterator end() {
		return iterator(m_tail);
	}
public:
	NODE m_head;
	NODE* m_tail;
	size_t m_size;
};

在这里插入代码片

四.为啥要使用函数对象(仿函数)

int main(){
	FunctionAdd add;
	//switch int string 自定义对象
	//map<string, FunctionAdd> 
	cout << add(10, 10) << endl;

	Test t1;
	Test1 t2;
	Func<Test, int(Test::*)(int, int)> f1(t1, &Test::test);
	Func<Test1, int(Test1::*)(int, int)> f2(t2, &Test1::test);
	f1(10, 10);
	
	map<string, base*> s2Func;
	s2Func.insert(pair<string, base*>("hello", &f1));
	s2Func.insert(pair<string, base*>("world", &f2));
}

class FunctionAdd {
public:
	int operator()(int a, int b) {
		return a + b;
	}
};
class Test {
public:
	int test(int a, int b) { return a + b; };
};
class Test1 {
public:
	int test(int a, int b) { return a * b; };
};

class base {
public:
	virtual int operator()(int a, int b) = 0;
};

template<typename T, typename FUNC>
class Func:public base {
public:
	Func(T& o, FUNC f) :obj(o) {
		obj = o;
		func = f;
	}
	virtual int operator()(int a, int b) {
		(obj.*func)(a, b);
	};
private:
	T& obj;
	FUNC func;
};