模板相关知识点

模板的概念,模板的精神<了解+掌握>

模板就是一个模具,通过这个模具我们倒入不同材质的东西,浇筑成了一个我们想要的那个材质的物品
这个材质在我看来就是我们的参数类型,我们各种属性的类型.
模板是代码复用的一种手段,是泛型编程的基础,所谓的泛型编程就是编写与类型无关的代码

函数模板<掌握>

函数模板的写法

template<class  T> 
函数类型 函数名字( T 函数的参数名字) 
{}


template<class T> 
T add(T right,T left) {
	return right+left;
}

int main () {
	cout<<add<int>(10,20);
	return 0;
}

在编译的期间,对于模板函数的类型,我们的编译器会做出参数的类型推演,对这些参数推演生成对应类型的函数,以供调用,比如上面的函数,我们的编译器对我们的实参类型做出推演,这个时候,将T 确定为int类型,让后生成一份专门处理int类型的代码.

函数模板的匹配规则
当函数模板和同名函数模板同时存在的时候这个函数模板可以被实例化为非模板函数
对于非模板函数和同名的函数模板,如果其他条件都相同,在调用时候,会有限调用非模板函数而不会从该模板产生出一个实例,如果模板有更好的匹配的函数,那么将会选择模板

函数模板并不是真正的函数,是编译器生成代码的模具,我们真正在执行函数的时候调用的是我们生成的函数
所以我们在使用函数模板的时候有两步
1.创建函数模板
2.正确的调用函数的模板

类模板<掌握>

除了有函数的模板,我们的类模板在实际的用途中还是非常的常见的
类模板的基础写法
最后我们的析构函数是在我们类外写的,写的时候我们需要在类里面进行声明,在类外加上作用域符号

template<class T>
calss 类名 
{};

//下面模拟一下vector模板
namespace Test{
	template<class T>
	class Vector{
	public:
		Vector(size_t capacity = 15) :_pData(new T[capacity]),
			_capacity(capacity),
			_size(0)
		{}
		size_t Size() {
			return _size;
		}
		void push_back(T data);

		T& operator[](size_t pos) {
			assert(pos < _size);
			return _pData[pos];
		}

		~Vector();

	private:
		T* _pData;
		size_t _size;
		size_t _capacity;
	};
	template<class T>
	Vector<T>::~Vector() {
		if (_pData) {
			delete[]_pData;
		}
		_size = _capacity = 0;
	}

	template<class T>
	void Vector<T>::push_back(T data){}
}

模板的实例化<掌握>

类模板

类模板的显式实例化需要在类模板名字后面跟**<>**,然后将实例化的类型放在<>中即可,类模板名字不是真正的类,实例化以后的结果才是真真的类,就像我们刚才在使用vector类一样
类模板隐式实例化指的是在使用模板类时才将模板实例化，相对于类模板显示实例化而言的。考察如下程序。

#include <iostream>
using namespace std;
template<typename T>class A{
    T num;
public:
    A(){
        num=T(6.6);
    }
    void print(){
        cout<<"A'num:"<<num<<endl;
    }
};

int main(){
    A<int> a; //显示模板实参的隐式实例化
    a.print();
}

函数模板

函数模板的隐式实例化/显式实例化
函数模板的隐式实例化值指的是让编译器根据实参推演模板参数的实际类型
显式的实例化就是像我们的类模板实例化一样,在函数的名字后面加<>注明类型即可

template<class T> 
T add(T right, T left) {
	return right + left;
}
int main() {
	int a1 = 10, a2 = 20;
	add(a1, a2);
	double d1 = 10.0, d2 = 13.3;
	add(d1, d2);
	add(a1, d1);

	return 0;
}

执行了add函数的时候,前面两条函数我们的编译器都可将参数推演出来,虽然我们并没有给出实例化出类型,但是第三个函数就不行了,在模板中我们的编译器一般不会进行类型转换的操作.因为一旦转换出了问题,编译器就需要背黑锅

还有一种简介调用函数的情况，也可以完成函数模板的实例化。所谓的简介调用是指将函数入口地址传给一个函数指针，通过函数指针完成函数调用。如果传递给函数指针不是一个真正的函数，那么编译器就会寻找同名的函数模板进行参数推演，进而完成函数模板的实例化。参考如下示例。

#include <iostream>
using namespace std;
template <typename T> void func(T t){
    cout<<t<<endl;
}

void invoke(void (*p)(int)){
    int num=10;
    p(num);
}
int main(){
    invoke(func);
}

非类型模板参数

模板参数分为类型形参,出现在模板参数列表中,更在class或者typename之类的参数类型名称
非类型形参,就是一个常量作为类模板的一个参数,在类模板中可以将这个参数当成常量来使用

template<class T,size_t N = 10>
class array{
//................
};
**
**

浮点型,类对象,以及字符集不允许被认作非类型模板参数的
非类型的模板参数必须在编译期间就可以确定结果

模板的特化

特化就是参数类型设置为你想要的类型这不过这个模板得先建立好在模板的上面的参数进行特殊化处理
对于函数模板的特化
必须得有一个基础的函数模板
关键字后面template后面必须接一堆尖括<>
函数名字后面跟一对尖括号,尖括号后面跟的是需要特化的类型
函数形参表:必须要和我们模板函数的基础参数类型相同,

template<class T> 
bool IsEqual(T& left, T& right) {
	if (left == right)
		return true;
	return false;
}

template<>
bool IsEqual<char*>(char*& left, char*& right) {
	if (strcmp(left, right) > 0)
		return true;

	return false;
}

在对函数模板进行特化的时候,其实他是不如我们给出普通函数的效果好的

类模板特化的几种方式:
全特化 模板中的参数类型全都确定下来

偏特化 对参数的类型进行条件的限制,确定部分的参数类型
参数部分特化
对参数进行进一步限制而定特殊化处理比如指针或者引用类型

//基础的模板需要给出来
template<class T1,class T2>
class Date {
public:
	Date(){
		cout << "Date<T1,T2>" << endl;
	}

private: 
	T1 _d1;
	T2 _d2;
};

//全特化,将所有类型进行特殊化处理
template<>
class Date<int,char>{
public:
	Date() {
		cout << "Date<int,char>" << endl;
	}
private:
	int  _d1;
	char _d2;
};


// 部分特化,将部分类型进行特殊化的处理
template<class T1>
class Date<char ,T1> {
public:
	Date() {
		cout << "Date<T1,char>" << endl;
	}

private:
	T1 _d1;
	char _d2;
};

//参数的更近一步的限制
template<>
class Date<int *,char*>
{
public:
	Date(){
		cout << "Date<int *,char *>" << endl;
	}

private:
	int* _d1;
	char* _d2;

};

模板的类型萃取

萃取就是提取合适的类型做出相应类型的操作,比如说对于变量的拷贝,当他是自定义类型的时候,就需要我们来做出相应的操作了
下面我们用一个通用的拷贝函数举例子,我们的自定义类型是string类型
C++类型萃取

//定义一个string类,这类由我们来实现,因为牵扯到深浅拷贝的问题
class String {
public:
	String(const char *str = ""){
		if (str == nullptr) {
			_str = "";
		}
		_str = new char(strlen(str) + 1);
		strcpy(_str, str);
	}

	String(const String& s):_str(new char[strlen(s._str)+1]) {
		if (this != &s) {
			strcpy(_str, s._str);
		}
	}
	String& operator=(const String& s) {
		if (this != &s) {
			/*char* newstr = new char[strlen(s._str) + 1];
			strcpy(newstr, s._str);
			free(_str);
			_str = newstr;*/
			String s1(s);
			char* tmp = s1._str;
			s1._str = _str;
			_str = tmp;
		}
		return *this;
	}
	~String() {
		if (_str == nullptr) {
			return;
		}
		delete[]_str;
		_str = nullptr;
	}

private:
	char *_str;
};

//类型萃取就是类模板特化的应用
template<class T>
//通用拷贝函:任意的类型都可以进行拷贝
void Copy(T* dst, T* src, size_t size) {
	//内置类型,自定义类型需要进行区分
	//枚举的方法,比较繁琐   	if(IsPODType(typeid(T).name())){

	
	//采用类型萃取的方法
	//第一次进来的时候我们编译器已经对这个类型做出了处理是一个int,这时候走的特化版本
	//template<>
	/*struct TypeTraits<int> {
		typedef TrueType  IsPODType	
	}*/
	if (TypeTraits<T>::IsPODType::Get()) {
		//将地址的内容直接拷贝,但是地址的内容里面其实还是地址
		//内存泄露
		//浅拷贝
		//效率高
		memcpy(dst, src, sizeof(T)*size);
	}
	else {
		//优点:一定不会出错.你需要给出赋值重载
		//缺陷:效率低
		for (size_t i = 0; i < size; ++i) {
			//这时候是类类型的时候就会去调用类类型运算符重载函数
			dst[i] = src[i];
		}
	}
}
//这两个类里面都有静态的成员函数,这时候调用一下,就可以完成这个区分,在编译期间我们的编译器就已经
//将T的类型做出了区分
struct FalseType {
	static bool Get() {
		return false;
	}
};
struct TrueType { 
	static bool Get() {
		return true;
	}
};

//类型模板
template<class T> 
struct TypeTraits {
	//给这个IsPODType 取了一个别名,这样的话IsPODTYpe可以使falsetype,也可以是truetype
	//falseType --- 不是内置类型
	//trueType 就是一个内置的类型,就是我们特化的处理方式
	//是一个结构体TypeTraits模板` 
	typedef FalseType IsPODType;
};


//类型模板的特化
template<>
struct TypeTraits<int> {
	typedef TrueType IsPODType;
};


template<>
struct TypeTraits<long> {
	typedef TrueType IsPODType;
};

模板的分离编译

对于模板的分离编译我是学习的这个链接