显而易见的解决方案 企业解决方案_管理咨询公司名称参考_网站关键词优化排名_海南百度推广公司

模板

1. 非类型模板参数

模板参数分类类型形参与非类型形参。
类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。
非类型形参应用和与宏的对比：
宏不能加分号，这里写死只能定义一个

#include<iostream>
using namespace std;
//#define N 20     //宏不能加分号，这里写死只能定义一个
//非类型模版参数
//只支持整型
template<class T,size_t N =10>
class Stack
{
private:T _a[N];int _top;
};
//c++20以后才支持浮点类型
//template<class T, double N = 10.1>  
//class Array
//{
//private:
//	T _a[N];
//	int _top;
//};
int main()
{//Stack<int> st1;Stack<int> st0;//10Stack<int,20> st1;//20Stack<int,2000> st2;//2000return 0;
}

扩展 std::array

#include<array>
#include<vector>int main()
{//Stack<int> st1;Stack<int> st0;//10Stack<int,20> st1;//20Stack<int,2000> st2;//2000array<int, 100> a1;array<int, 200> a2;int aa1[100];int aa2[200];//cout << aa1[105] << endl;//越界检查不出//cout << a1[105] << endl; //限制了size可以检查出越界//vector 更好用vector<int> v1(100, 1);return 0;
}

cout << a1[105] << endl; //限制了size可以检查出越界

2. 模板的特化

2.1 概念

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板

2.2 函数模板特化

函数模板的特化步骤：

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

class Date
{
public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}bool operator<(const Date& d)const{return (_year < d._year) ||(_year == d._year && _month < d._month) ||(_year == d._year && _month == d._month && _day < d._day);}bool operator>(const Date& d)const{return (_year > d._year) ||(_year == d._year && _month > d._month) ||(_year == d._year && _month == d._month && _day > d._day);}friend ostream& operator<<(ostream& _cout, const Date& d);
private:int _year;int _month;int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{_cout << d._year << "-" << d._month << "-" << d._day;return _cout;
}// 函数模板的特化 -- 参数匹配
#include"Queue.h"
template<class T>
bool Less(T left, T right)
{return left < right;
}
//特化模版，要排在默认的后面，不然走不通
//特化（对Date*特殊化处理）
template<>//注意：要特化模版参数为空
bool Less<Date*>(Date* left, Date* right)
{return *left < *right;
}//用函数重载取代替特化
//bool Less(Date* left, Date* right)
//{
//	return *left < *right;
//}
int main()
{cout << Less(1, 2) << endl; // 可以比较，结果正确Date d1(2022, 7, 7);Date d2(2022, 7, 8);cout << Less(d1, d2) << endl; // 可以比较，结果正确//Date* p1 = &d1;//Date* p2 = &d2;Date* p1 = new Date(2025, 2, 2);Date* p2 = new Date(2025, 4,2);cout << Less(p1, p2) << endl; // 可以比较，结果错误(随机)；有特化模版走特化（结果正确），没特化模版走默认return 0;
}

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

//用函数重载取代替特化
bool Less(Date* left, Date* right)
{return *left < *right;
}

2.3 类模板特化

2.3.1 全特化

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

template<class T1, class T2>
class Data
{
public:Data() { cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;
};
//全特化
template<>
class Data<int, char>
{
public:Data() { cout << "Data<int, char>" << endl; }
private:int _d1;char _d2;
};
int main()
{Data<int, int> d1;Data<int, char> d2;return 0;
}

2.3.2 偏特化

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。
偏特化有以下两种表现方式：
(1)部分特化
将模板参数类表中的一部分参数特化
(2)参数更进一步的限制
偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

template<class T1, class T2>
class Data
{
public:Data() { cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;
};
//全特化
template<>
class Data<int, char>
{
public:Data() { cout << "Data<int, char>" << endl; }
private:int _d1;char _d2;
};
//偏特化---特化部分参数
template <class T1>
class Data<T1, int>
{
public:Data() { cout << "Data<T1, int>" << endl; }
private:T1 _d1;int _d2;
};//参数更进一步的限制
//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{
public:Data() { cout << "Data<T1*, T2*>" << endl; }
private:
};//两个参数偏特化为引用类型
template <typename T1, typename T2>
class Data <T1&, T2&>
{
public:Data()//不能加参数会报错{cout << "Data<T1&, T2&>" << endl;}
private:};template <typename T1, typename T2>
class Data <T1*, T2&>
{
public:Data(){cout << "Data<T1*, T2&>" << endl;}
private:};template <typename T1, typename T2>
class Data <T1&, T2*>
{
public:Data(){cout << typeid(T1).name() << endl;cout << typeid(T2).name() << endl;cout << "Data<T1&, T2*>" << endl;}
private:
};
int main()
{Data<int, int> d1;Data<int, char> d2;Data<char, char> d3;Data< char, int> d4;Data< char*, int*> d5;Data< char*, int&> d6;Data< char&, int*> d7;return 0;
}

2.3.3 类模板特化应用示例

#include<vector>
#include<algorithm>
template<class T>
struct Less
{bool operator()(const T& x, const T& y) const{return x < y;}
};
int main()
{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);// 可以直接排序，结果错误日期还不是升序，而v2中放的地址是升序// 此处需要在排序过程中，让sort比较v2中存放地址指向的日期对象// 但是走Less模板，sort在排序时实际比较的是v2中指针的地址，因此无法达到预期sort(v2.begin(), v2.end(), Less<Date*>());return 0;
}

通过观察上述程序的结果发现，对于日期对象可以直接排序，并且结果是正确的。但是如果待排序元素是指针，结果就不一定正确。因为：sort最终按照Less模板中方式比较，所以只会比较指针，而不是比较指针指向空间中内容，此时可以使用类版本特化来处理上述问题：

// 对Less类模板按照指针方式特化
template<>
struct Less<Date*>
{
bool operator()(Date* x, Date* y) const
{
return *x < *y;
}
};

3 模板分离编译

3.1 什么是分离编译

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

3.2 模板的分离编译

分析：链接时，Func可以链接成功，Add无法链接成功
why？
test.i中知道Add需要实例化成int和double各一份Add函数，但是他只有声明没有定义。
a.i中知道有Add的定义，但是不知道实例化成类型。
a.h

#pragma once
#include<iostream>
using namespace std;
//函数模版
template<class T>
T Add(const T& left, const T& right);void Func(int x);

a.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include"a.h"//template<class T>
//T Add(const T& left, const T& right);
//
//
//void Func(int x);
template<class T>
T Add(const T& left, const T& right)
{return left + right;
}void Func(int x)
{cout << "void Func(int x)" << endl;
}

test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
//模板分离编译
#include"a.h"
//template<class T>
//T Add(const T& left, const T& right);
//
//
//void Func(int x);
int main()
{Add(1, 2);Add(1.0, 2.0);Func(10);return 0;
}

3.3 解决方法

3.1显示实例化（但是不好用）

a.h

#pragma once
#include<iostream>
using namespace std;
//函数模版
template<class T>
T Add(const T& left, const T& right);
void Func(int x);

a.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include"a.h"//template<class T>
//T Add(const T& left, const T& right);
//
//
//void Func(int x);
template<class T>
T Add(const T& left, const T& right)
{return left + right;
}void Func(int x)
{cout << "void Func(int x)" << endl;
}//显示实例化
template
int Add(const int& left, const int& right);template
double Add(const double& left, const double& right);

test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
//模板分离编译
#include"a.h"
//template<class T>
//T Add(const T& left, const T& right);
//
//
//void Func(int x);
int main()
{cout<<Add(1, 2)<<endl;cout<<Add(1.0, 2.0)<<endl;//cout << Add('a', 'x') << endl;Func(10);return 0;
}

3.2 不要声明和定义到两个文件,直接定义在.h

本质：不存在链接要去找的问题，定义就在.h,在编译的时候就已经确定地址了。
a.h

#pragma once
#include<iostream>
using namespace std;
//函数模版
template<class T>
//T Add(const T& left, const T& right);
T Add(const T& left, const T& right)
{return left + right;
}void Func(int x);

4. 模板总结

【优点】

1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
2. 增强了代码的灵活性
   【缺陷】
3. 模板会导致代码膨胀问题，也会导致编译时间变长
4. 出现模板编译错误时，错误信息非常凌乱，不易定位错误

总结

以上就是模版进阶（沉淀中）的全部内容了，喜欢这篇文章，可以一键三连，支持博主。