【C++模板进阶】非类型模板函数，模板的特化，为什么不支持分离编译及解决，按需实例化

目录

目录

1. 非类型模板参数

2.模板的特化（特殊化处理）

                1.函数模板的特化

                2.类模板的特化 

3.模板分类编译

4.总结

---

1. 非类型模板参数

如果我们对象的成员变量是一个数组，要开辟100个单位空间，或者开辟1000的空间，可以用宏定义即define；缺点是如果同时开辟100和1000，定义的宏不够用（不灵活）

#define N 1000

template<class T=int>
class Array
{
public:
private:
	T _a[N];
};
int main()
{
	Array<int> a1;//100
	Array<int> a2;//1000

	return 0;
}

模板参数分： 类型模板形参，非类型模板形参。

类型模板形参：出现在模板参数列表中，跟在class之后的参数类型名称。

非类型模板形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。 

使用非类型模板参数

• 非类型模板参数一定是整形常量（不能是浮点型，字符串），模板参数都可以使用缺省值

// 类型模板参数
// 非类型模板参数 -- 整形常量
template<class T=int,size_t N=100>
class Array
{
public:
private:
	T _a[N];
};
int main()
{
	Array<int, 100> a1;
	Array<int,1000> a2;

	return 0;
}

int main()
{
	Array<int, 100> a1;
	Array<int,1000> a2;
	return 0;
}

2.模板的特化（特殊化处理）

                1.函数模板的特化

首先我们来看下面这对，比较2数是否相等的代码（相等返回1，不等返回0）

template<class T>
bool IsEqual(const T& left, const T& right)
{
	return left == right;
}
int main()
{
	int a = 1;
	int b = 1;
	cout << IsEqual(a, b) << endl;
	double c = 1.1;
	double d = 1.1;
	cout << IsEqual(c, d) << endl;
	const char p1[] = "hello";
	const char p2[] = "hello";
	cout<< IsEqual(p1,p2) << endl;
	const char* p3 = "hello";
	const char* p4 = "hello";
	cout << IsEqual(p3, p4);
	return 0;
}

结果

思想

 特化后代码

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

bool IsEqual(const char*& left, const char*& right)
{
	return strcmp(left, right) == 0;
}

int main()
{
	int a = 1;
	int b = 1;
	cout << IsEqual(a, b) << endl;
	double c = 1.1;
	double d = 1.1;
	cout << IsEqual(c, d) << endl;
	const char p1[] = "hello";
	const char p2[] = "hello";
	cout<< IsEqual(p1,p2) << endl;
	const char* p3 = "hello";
	const char* p4 = "hello";
	cout << IsEqual(p3, p4);
	return 0;
}

函数模板特化的特性

•  必须要先有一个基础的函数模板
•  关键字template后面接一对空的尖括号<>
•  函数名后跟一对尖括号，尖括号中指定需要特化的类型
•  函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

  2.类模板的特化 

模板的全特化：是将模板参数列表中所有的参数都确定化

template<class T1, class T2,class T3>
class Date
{
public:
	Date() { cout << "Date<T1, T2, T3>" << endl; }
private:
	T1 _year;
	T2 _month;
	T3 _day;
};

// 假设针对T1 T2是 int int想做一些特殊化那么怎么办 ？ -- 类模板特化
// -- 全特化
template<>
class Date < int, int, int >
{
public:
	Date() { cout << "Date<int, int, int >" << endl; }
};

模板的偏特化：是将模板参数列表中一部分参数都确定化

template<class T1, class T2,class T3>
class Date
{
public:
	Date() { cout << "Date<T1, T2, T3>" << endl; }
private:
	T1 _year;
	T2 _month;
	T3 _day;
};

// 将第二个和第三个参数特化为int --偏特化
template <class T1>
class Date < T1, int, int >
{
public:
	Date() { cout << "Date<T1, int, int >" << endl; }
};

模板还可以指针或者引用特化

template <class T1, class T2,class T3>
class Date <T1*, T2*,T3*>
{
public:
	Date() { cout << "Date<T1*, T2*, T3* >" << endl; }
};

template <class T1, class T2,class T3>
class Date < T1&, T2& , T3& >
{
public:
	Date() { cout << "Date<T1&, T2& ,T3& >" << endl; }
};

3.模板分类编译

什么是分离编译 ：一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链 接起来形成单一的可执行文件的过程称为分离编译模式。

为什么不支持分离编译 

解决方式1 

在定义里面显示实例化，那么就会调用对应的，但是每一个不同的类型就需要写一个，麻烦

#include"template.h"

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

void func(int a, int b)
{
	cout << a << endl;
	cout << b << endl;
}

template<>
int Add<int>(const int& left, const int& right);
template<>
double Add<double>(const double& left, const double& right);

解决方法2

声明定义放一起，不麻烦

#pragma once
#include <iostream>
using namespace std;

// 模板函数
template<class T>
T Add(const T& left, const T& right);

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
//普通函数
void func(int a, int b);

4.总结

 什么是按需实例化

• f3没调用就不会实例化生成;

template<class T>
class AT
{
public:
	void f1(const T& x)
	{
		cout << "void f1()" << endl;
	}

	void f2(const T& x)
	{
		cout << "void f2()" << endl;
	}

	void f3(const T& x)
	{
		cout << "void f3()" << endl
	}
};

int main()
{
	AT<int> at1;
	AT<double> at2;
	AT<char> at3;

	at1.f1(0);
	at2.f1(1.1);
	at3.f2(1.1);

	return 0;
}