C++模板进阶(非类型模板参数和模板特化)

最新推荐文章于 2024-10-28 22:13:06 发布

原创最新推荐文章于 2024-10-28 22:13:06 发布 · 946 阅读

3 ·

CC 4.0 BY-SA版权

C++ 专栏收录该内容

32 篇文章

订阅专栏

本文详细探讨了C++模板中的非类型参数及其限制，以及模板特化，包括函数模板和类模板的全特化与偏特化。通过示例解释了为何需要模板特化，并介绍了模板在分离编译模式下遇到的问题及解决方案。

C++模板进阶

1.非类型模板参数
2.模板的特化
3.模板的分离编译

1.非类型模板参数

模板参数分为类类型形参和非类型形参。

类类型参：出现在模板参数列表中，跟在class或者typename之后的参数类型名称，比如int,char,string等，也可以是自己实现的自定义类型。
非类型参：就是用一个常量作为模板(类模板和函数模板)的一个参数，在模板中可将该参数当成常量来使用。

1.非类型模板参数只能是三种:const 整型, const 指针, const 引用, 其他类型都不行, 因为模板参数必须在编译期就能确认结果。
2. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。

定义一个模板类型的静态数组

#include<iostream>
using namespace std;

template<typename T,size_t N=10>//非类型模板参数
class Array {
	T m_array[N];
	size_t m_size;
public:
	Array() :m_size(N) {};
	T& operator[](size_t n) {
		return m_array[n];
	}
	const T& operator[](size_t n)const  {
		return m_array[n];
	}
	size_t size()const {
		return m_size;
	}
	bool empty()const {
		return 0 == m_size;
	}
};
class Test {
public:
	template<typename T,size_t N=10>
	void Solution(Array<T, N>& a) {
		int size = a.size();
		for (int i = 0; i < size; ++i) {
			a[i] = i + 1;
		}
		for (int i = 0; i < size; ++i) {
			cout << a[i] << " ";
		}
		cout << endl;
	}
};
int main() {
	Test test;
	Array<int> a;
	Array<int, 15> b;
	const int N = 20;
	Array<int, N> c;
	test.Solution(a);
	test.Solution(b);
	test.Solution(c);
	return 0;

}

在这里插入图片描述

2.模板的特化

2.1概念

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，比如：

#include<iostream>
#include<string>
using namespace std;
template<typename T>
bool IsEqual(T a, T b) {
	return a == b;
}
int main() {
	string s1 = "abc";
	string s2 = "abc";
	string s3 = "abcd";
	int a = 10;
	int b = 10;
	int c = 20;
	IsEqual(s1, s2) ? cout << "s1==s2" << endl : cout << "s1!=s2" << endl;
	IsEqual(s1, s3) ? cout << "s1==s3" << endl : cout << "s1!=s3" << endl;
	IsEqual(a, b) ? cout << "a==b" << endl : cout << "a!=b" << endl;
	IsEqual(a, c) ? cout << "a==c" << endl : cout << "a!=c" << endl;
	cout << endl;
	IsEqual(&s1, &s2) ? cout << "s1==s2" << endl : cout << "s1!=s2" << endl;
	IsEqual(&s1, &s3) ? cout << "s1==s3" << endl : cout << "s1!=s3" << endl;
	IsEqual(&a, &b) ? cout << "a==b" << endl : cout << "a!=b" << endl;
	IsEqual(&a, &c) ? cout << "a==c" << endl : cout << "a!=c" << endl;
	return 0;
}

在这里插入图片描述
我们可以发现，当函数传入参数支持==比较，函数运行没有问题，都可以得到相对应的结果。而当函数传入指针时，IsEqual()函数比较的是指针的大小。从IsEqual()的定义可以看出这个函数是无法比较指针大小的。这时就需要对这个函数模板的传入类型进行特化。

2.2函数模板的特化

函数模板的特化步骤：

必须要先有一个基础的函数模板
关键字template后面接一对空的尖括号<>
函数名后跟一对尖括号，尖括号中指定需要特化的类型。
函数模板没有偏特化(只能将所有模板参数特化)

#include<iostream>
#include<string>
using namespace std;
//基础的函数模板
template<typename T>
bool IsEqual(T a, T b) {
	return a == b;
}
//函数模板特化
//关键字template后面接一对空的尖括号<>
template<>
 //函数名后跟一对尖括号，尖括号中指定需要特化的类型
bool IsEqual<string*>(string* a, string* b) {
	return *a == *b;
}
template<>
bool IsEqual<int*>(int* a, int* b) {
	return *a == *b;
}

int main() {
	string s1 = "abc";
	string s2 = "abc";
	string s3 = "abcd";
	int a = 10;
	int b = 10;
	int c = 20;
	IsEqual(s1, s2) ? cout << "s1==s2" << endl : cout << "s1!=s2" << endl;
	IsEqual(s1, s3) ? cout << "s1==s3" << endl : cout << "s1!=s3" << endl;
	IsEqual(a, b) ? cout << "a==b" << endl : cout << "a!=b" << endl;
	IsEqual(a, c) ? cout << "a==c" << endl : cout << "a!=c" << endl;
	cout << endl;
	IsEqual(&s1, &s2) ? cout << "s1==s2" << endl : cout << "s1!=s2" << endl;
	IsEqual(&s1, &s3) ? cout << "s1==s3" << endl : cout << "s1!=s3" << endl;
	IsEqual(&a, &b) ? cout << "a==b" << endl : cout << "a!=b" << endl;
	IsEqual(&a, &c) ? cout << "a==c" << endl : cout << "a!=c" << endl;
	return 0;
}

在这里插入图片描述

2.3类模板的特化

类模版的特化分为全特化和偏特化
全特化: 类模版的所有模板参数都确定化
偏特化: 偏特化具体表现为部分特化和模板参数进一步限定

         部分特化: 将模板参数中的一部分特化
         模板参数进一步限定 : 对所有的模板参数进行限定

2.3.1全特化

#include<iostream>
#include<string>
using namespace std;

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

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

int main() 
{
    Data<int, int> d1;
    Data<int, char> d2;
    return 0;
}

在这里插入图片描述

2.3.2偏特化

1.部分特化

#include<iostream>
#include<string>
using namespace std;

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

//部分特化
template<typename T1>
class Data<T1, char>
{
public:
    Data() { 
        cout << "Data<T1, char>" << endl; 
    }
};

int main() 
{
    Data<int, int> d1;
    Data<double, char> d2;
    return 0;
}

在这里插入图片描述
2.模板参数进一步限定
偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。我们通常用于指针, 引用的特化, 如将T特化为T*, 也可以将T特化为 const T*, T&, const T&等。

#include<iostream>
#include<string>
using namespace std;

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

//模板参数进一步限定

//特化的指针版本
template<typename T1,typename T2>
class Data<T1*,T2*>
{
public:
    Data() { 
        cout << "Data<T1*, T2*>" << endl; 
    }
};
//特化的引用版本
template<typename T1, typename T2>
class Data<T1&, T2&>
{
public:
    Data() {
        cout << "Data<T1&, T2&>" << endl;
    }
};

int main() 
{
    Data<double, int> d1; // 调用特化的int版本
    Data<int, double> d2; // 调用基础的模板
    Data<int*, int*> d3; // 调用特化的指针版本
    Data<int&, int&> d4;//调用特化的引用版本
    return 0;
}

在这里插入图片描述

3.模板的分离编译

3.1什么是分离编译

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

3.2模板的分离编译

假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：

// a.h
template<class T>
T Add(const T& left, const T& right);

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

// main.cpp
#include"a.h"
int main()
{
 Add(1, 2);
 Add(1.0, 2.0);
 return 0;
}

当我们将函数模板声明在.h头文件，而定义在.cpp文件中进行分离编译，会出现错误：在链接时找不到实例化出的模板函数或模板类。这是因为C/C++程序要运行，一般需要经历一下步骤：预处理—>编译—>汇编—>链接。函数模板或类模板只有在编译时, 才会生成一个真正的实体(模板函数或模板类), 这个过程在编译时完成, 而 分离编译时多文件各自编译各自的, 所以在.cpp中的模板定义在编译时并不知道到底要实例化出一个怎样的模板函数或模板类, 所以就不会实例化。 当在链接阶段, 需要链接这个模板函数或模板类时就会报错。