• C++模板进阶之非类型模板参数、模板特化

    文章目录

    问题引出

    当我们想要输出包含不同类型的list时，尝试使用泛型编程，写出下面的代码👇

    template<class T>
void print_list(const list<T>& lt)
{
	list<T>::const_iterator cit = lt.begin();
	while (cit != lt.end())
	{
		cout << *cit << " ";
		++cit;
	}
	cout << endl;
}

void test_template1()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	print_list(lt);

	list<string> ltstr;
	ltstr.push_back("aaa");
	ltstr.push_back("bbb");
	ltstr.push_back("ccc");
	ltstr.push_back("ddd");
	print_list(ltstr);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    却发现编译都过不了。

    image-20220811130615852

    这是因为类模板里面包含了虚拟类型，编译器找不到内嵌类型的具体定义。

    要利用typename关键字，声明后面的虚拟类型只是个类型，等模板实例化之后再去操作。
    类模板没有实例化的时候，找出来的也是虚拟类型，后期无法处理。

    template<class T>
void print_list(const list<T>& lt)
{
	// 这是一个虚拟类型 类模板没有实例化的之前，不能去取list里面的内嵌类型
	// 在前面加上typename关键字，告诉编译器后面的list::const_iterator是一个类型
	// 等类模板实例化完成之后再去取
	// 这里是list确定了，但list模板参数还没确定
	typename list<T>::const_iterator cit = lt.begin();
	while (cit != lt.end())
	{
		cout << *cit << " ";
		++cit;
	}
	cout << endl;
}

template<class Container>
void print_container(const Container& con)
{
	// 这也是一个虚拟类型，整体都没有确定
	// typename 只是告诉编译器后面一串东西是类型 等实例化完成之后再去找
	typename Container::const_iterator cit = con.begin();
	while (cit != con.end())
	{
		cout << *cit << " ";
		++cit;
	}
	cout << endl;
}

void test_template1()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	print_list(lt); // 1 2 3 4
	print_container(lt); // aaa bbb ccc ddd

	list<string> ltstr;
	ltstr.push_back("aaa");
	ltstr.push_back("bbb");
	ltstr.push_back("ccc");
	ltstr.push_back("ddd");
	print_list(ltstr); // 1 2 3 4
	print_container(ltstr); // aaa bbb ccc ddd
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    当然，如果把T写成具体类型，也是可以通过编译的。

    void print_list(const list<int>& lt)
{
	typename list<int>::const_iterator cit = lt.begin();
	while (cit != lt.end())
	{
		cout << *cit << " ";
		++cit;
	}
	cout << endl;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    当然，如果用auto去自动推导类型，也是不用再加上typename的

    template<class T>
void print_list(const list<T>& lt)
{
	auto cit = lt.begin();
	while (cit != lt.end())
	{
		cout << *cit << " ";
		++cit;
	}
	cout << endl;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    非类型模板参数

    引例

    举个例子👇

    借助模板，我们可以在一个Stack里面存不同类型，但如果还想存不同的个数呢？

    #define N 50
// 静态栈
template<class T>
class Stack {
private:
	T _a[N];
	int _top;
};

void test_template2()
{
	Stack<int> st1; // 存50个
	Stack<double> st2; // 我想存500个呢？
}
int main()
{
	test_template2();
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    借助非类型模板参数

    // 静态栈
// 利用非类型模板参数
// N是常量，也意味着不可以修改
template<class T, size_t N = 100> // 也是可以给定缺省参数的 
class Stack
{
public:
	void f()
	{
		N = 20; // err 不允许修改
	}
private:
	T _a[N];
	int _top;
};

void test_template2()
{
	Stack<int, 50> st1; // 存50个
	st1.f();
	Stack<double, 500> st2; // 存500个
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    定义

    模板参数可分为类型形参和非类型形参。
    类型形参： 出现在模板参数列表中，跟在class或typename关键字之后的参数类型名称。
    非类型形参： 用一个常量作为类（函数）模板的一个参数，在类（函数）模板中可将该参数当成常量来使用。

    array

    库里的array容器就是这样
    在这里插入图片描述

    void test_template3()
{
	// v1数据存在堆上的
	vector<int> v1(100, 0);
	v1[0] = 0;
	v1[1] = 1;
	// ...
	v1[99] = 99;
	cout << sizeof(v1) << endl; // 16  32位平台下


	// 数据存在栈上，没有初始化的话都是随机数据
	// array是C++11新增的 -- 其实就是封装过的原生数组
	// 对比原生数组的优势：operator[] 能严格检查越界
	// 越界读越界写都能检查到
	array<int, 100> a1;
	a1[0] = 0;
	a1[1] = 1;
	// ...
	a1[99] = 99;
	cout << sizeof(a1) << endl; // 400byte
	//a1[200] = 1;
	//cout << a1[200] << endl;

	int a2[100]; // 原生数组 针对越界是抽查，有时检查不到
	a2[200] = 1;
	a2[200];
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    总的来说，array根本不配和vector对比，只能勉强和原生数组比较一下。

    注意：

    1. 非类型模板参数只允许使用整型家族，浮点数、类对象以及字符串是不允许作为非类型模板参数的。
    2. 非类型的模板参数在编译期就需要确认结果，因为编译器在编译阶段就需要根据传入的非类型模板参数生成对应的类或函数。

    基本都是int、size_t、char

    模板特化

    概念

    举一个简单例子来说明什么是模板特化。

    template <class T>
bool Less(T left, T right)
{
	return left < right;
}

void test_template4()
{
	cout << Less(1, 2) << endl; // 1 结果正确

	Date d1(2022, 8, 11);
	Date d2(2022, 8, 12);
	cout << Less(d1, d2) << endl; // 1 结果正确

	Date* p1 = new Date(2022, 8, 11);
	Date* p2 = new Date(2022, 8, 10);
	cout << Less(p1, p2) << endl; // 结果是随机的，无法比较
	cout << Less(*p1, *p2) << endl; // 正确
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    当我们去判断p1 p2 的大小时，实际上比较的并不是他们指向的内容的大小，而是他们本身的大小，p1 p2是指针，存在栈上，也就是比较的地址大小，每次开辟结果都有可能不同。

    类似于上述实例，使用模板可以实现一些与类型无关的代码，但对于一些特殊的类型可能会得到一些错误的结果，此时就需要对模板进行特化，即在原模板的基础上，针对特殊类型进行特殊化的实现方式

    函数模板特化

    对于上述实例，我们知道当传入的类型是Date* 时，应该调用Date类里面自身重载的比较运算符去比较，这样就完成了对Date*类型的特殊化实现。

    函数模板的特化步骤：

    1. 首先必须要有一个基础的函数模板。
    2. 关键字template后面接一对空的尖括号<>。
    3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型。
    4. 函数形参表必须要和模板函数的基础参数类型完全相同，否则不同的编译器可能会报一些奇怪的错误。
    template <class T>
bool Less(T left, T right)
{
	return left < right;
}

// 模板特化，针对某些特殊类型特殊化处理
template <>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    **注意：**一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。

    template <class T>
bool Less(T left, T right)
{
	return left < right;
}

// 模板特化，针对某些特殊类型特殊化处理
template <>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}

bool Less(Date* left, Date* right)
{
	return *left < *right;
}

// 为了针对int* int*
template <class T>
bool Less(T* left, T* right)
{
    return *left < *right;
}
// 这几个可以同时存在

void test_template5()
{
	cout << Less(1, 2) << endl; // 1 结果正确  调用原生的

	Date d1(2022, 8, 11);
	Date d2(2022, 8, 12);
	cout << Less(d1, d2) << endl; // 1 结果正确 调用原生的

	Date* p1 = new Date(2022, 8, 11);
	Date* p2 = new Date(2022, 8, 10);
	cout << Less(p1, p2) << endl; // 模板特化之后，结果就是正确的 调用Date*特化的
	cout << Less(*p1, *p2) << endl; // 正确 调用原生的

	int* p3 = new int(1);
	int* p4 = new int(2);
	cout << Less(p3, p4) << endl; // 正确 调用T*特化的
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    像Date* 这种特化实现简单明了，代码的可读性高，容易书写，因为对于一些参数类型复杂的函数模板，特化时特别给出，因此函数模板不建议特化。
    直接写一个具体类型的函数就好。

    类模板特化

    不仅函数模板可以进行特化，类模板也可以针对特殊类型进行特殊化实现，并且类模板的特化又可分为全特化和偏特化（半特化）。

    类模板的特化步骤：

    1. 首先必须要有一个基础的类模板。
    2. 关键字template后面接一对空的尖括号<>。
    3. 类名后跟一对尖括号，尖括号中指定需要特化的类型。

    全特化

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

    template<class T1, class T2>
class Data
{
public:
	Data() { cout << "Data" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

// 全特化
template<>
class Data<int, char>
{
public:
	Data() { cout << "Data" << endl; }
private:
	int _d1;
	char _d2;
};

void test_template6()
{
	Data<int, int> d1; // Data
	Data<int, char> d2; // Data
}
// 当没有第二个Data时，d1 d2都是调用原生模板

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    半特化

    也叫偏特化。

    偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。

    1. 部分特化

    将模板参数类表中的一部分参数特化。

    // 偏特化
// 1.将模板参数类表中的一部分参数特化。
// 只要第二个参数有double就匹配这个
template<class T1>
class Data<T1, double>
{
public:
	Data() { cout << "Data" << endl; }
private:
	int _d1;
	char _d2;
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    1. 参数进一步限制

    偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

    // 偏特化
// 2.参数更进一步限制
// 传2个指针才匹配这个
template<class T1, class T2>
class Data<T1*, T2*>
{
public:
	Data() { cout << "Data" << endl; }
private:
	int _d1;
	char _d2;
};

// 传2个引用就匹配
template<class T1, class T2>
class Data<T1&, T2&>
{
public:
	Data() { cout << "Data" << endl; }
private:
	int _d1;
	char _d2;
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    测试一下：

    void test_template6()
{
	Data<int, int> d1; // Data
	Data<int, char> d2; // Data
	Data<int, double> d3; // Data
	Data<double, double> d4; // Data
	Data<int*, double*> d5; // Data
	Data<double*, double*> d6; // Data
	Data<int&, double&> d7; // Data
	Data<int*, void*> d8; // Data
	Data<int*, string*> d9; // Data
	Data<int*, string> d10; // Data  //只有一个指针，去匹配原生的
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    举个例子👇：

    template<class T>
struct Less
{
	bool operator()(const T& x, const T& y) const
	{
		return x < y;
	}
};

// 全特化 但是针对其他类型指针就不好用了
//template<>
//struct Less
//{
//	bool operator()(Date* x, Date* y) const
//	{
//		return *x < *y;
//	}
//};

// 偏特化
template<class T>
struct Less<T*>
{
	bool operator()(T* x, T* y) const
	{
		return *x < *y;
	}
};

void test_template7()
{
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 6);
	Date d3(2022, 7, 8);

	vector<Date> v1;
	v1.push_back(d1);
	v1.push_back(d2);
	v1.push_back(d3);
	sort(v1.begin(), v1.end(), Less<Date>()); // 日期升序

	vector<Date*> v2;
	v2.push_back(&d1);
	v2.push_back(&d2);
	v2.push_back(&d3);
	sort(v2.begin(), v2.end(), Less<Date*>()); // 利用全特发/偏特化均可

	vector<int*> v3;
	v3.push_back(new int(3));
	v3.push_back(new int(1));
	v3.push_back(new int(2));
	sort(v3.begin(), v3.end(), Less<int*>()); // 利用偏特化
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53

    在这里插入图片描述

    再举个例子👇
    迭代器萃取中，就运用到了特化。

    对于自定义类型，比如list的迭代器，，里面是定义有pointer，reference等的内嵌类型
    而对于vector、string 等的迭代器是原生指针，

    在这里插入图片描述

    总结

    函数模板不太需要特化，类模板的特化中，偏特化适应情况更多。

    做个不恰当的比喻，全特化就像是煮熟的饭菜，偏特化就像是半生不熟的自热锅，原生泛型就是生菜生米。

    一篇好文章

    尾声

    🌹🌹🌹

    写文不易，如果有帮助烦请点个赞~ 👍👍👍

    Thanks♪(･ω･)ﾉ🌹🌹🌹

    😘😘😘

    👀👀由于笔者水平有限，在今后的博文中难免会出现错误之处，本人非常希望您如果发现错误，恳请留言批评斧正，希望和大家一起学习，一起进步ヽ(￣ω￣(￣ω￣〃)ゝ，期待您的留言评论。
    附GitHub仓库链接

  • 相关阅读:
    redis：常用的数据类型
    第一章：最新版零基础学习 PYTHON 教程（第一节 - 简介）
    【德哥说库系列】-RHEL8环境源码编译安装MySQL8.0
    下拉框判断是否重复选中值
    Android 开发小贴士
    前端数据可视化之【Echarts介绍】
    Python（8）序列
    vue源码学习
    OpenGauss的TPCE测试
    RustDay04------Exercise[01-10]
  • 原文地址：https://blog.csdn.net/a2076188013/article/details/126316863