（十六）模板与泛型编程
2024-05-14 07:49:40
（十六）模板与泛型编程
- 1定义模板
- 1.1函数模板
- 1.2类模板
- 1.2.1定义
- 1.2.2实例化
- 1.2.3类模板与友元
- 1.2.4类模板类型别名
- 1.2.5类模板静态函数
- 1.3模板参数
- 1.4成员模板
- 1.4.1非模板类的成员模板
- 1.4.2类模板的成员模板
- 1.5模板实例化控制
- 1.6 效率与灵活性
- 2 模板实参推断
- 2.1类型转换
- 2.1.1 隐式转换
- 2.1.2 显式转换
- 2.1.3 尾置返回类型
- 2.1.4 函数指针
- 2.1.5引用
- 2.1.5.1 左值引用
- 2.1.5.2 右值引用
- 2.1.5.3引用折叠的两个例外规则
- 2.1.6 std::move（右值引用的函数模板案例）
- 2.1.7 转发
- 3函数重载与模板
- 4可变参数模板
- 4.1可变参数模板
- 4.2转发参数包
- 5模板特例化
- 5.1模板特例化
- 5.2函数模板特例化
- 5.3类模板特例化
- 5.3.1类模板特例化
- 5.3.2类模板部分特例化
- 5.3.3特例化类成员
- 面向对象编程（OOP） ：能处理类型在程序运行之前都未知的情况
- 泛型编程：在编译时就能获知类型
- 模板：是泛型编程的基础，模板是创建类或函数的公式。
1定义模板
1.1函数模板
- 可以定义一个通用函数模板，通过定义类型参数，针对特定类型生成对应函数版本。当调用函数模板，编译器会用模板参数实例化一个特定版本的函数。
template<typename T>//模板定义中，模板参数列表不能为空
- 类型参数分为两种。
- 一种是模板类型参数，类型参数前要有关键字
class或typename，在模板参数列表中，二者没有区别。- 另一种是非类型模板参数，非类型参数表示一个值而非一个类型。通过特定类型名，如
unsigned来指定，做两个长度不同的数组比较。非类型参数可以是一个整型（实参是常量表达式），或者是一个指向对象或函数类型的指针或（左值）引用（实参要具有静态生存期）。
- 函数模板可以声明为
inline/constexpr：
template<typename T>inline T min(const T& t1, const T& t2) { return t1 < t2 ? t1 : t2; }
- 模板中函数参数是const的引用，保证函数可以用于不能拷贝的类型；
- 函数内部尽可能和使用标准库模板函数对象（P510）
- 对于模板编译：
当实例出模板的特定版本时，编译器才会生成代码。
考虑到生成实例化版本时，编译器需要掌握函数模板或类模板成员函数的定义，模板的声明和定义都会放到头文件中。
1.2类模板
- 用来生成类的蓝图。由于编译器不能为类模板推断模板参数类型，必须在模板名后的尖括号中提供额外信息。
1.2.1定义
- 以关键字template开始，后跟模板参数列表
- 类模板成员函数可以在模板内部（隐式内联），也可以在模板外部。定义在外部要以关键字template开始。
- 在类代码内可以简化模板类名的使用（比如从
hhdy<T>到hhdy）
template<typename T>
class hhdyptr {hhdyptr& operator++(); //类内可以简化模板类名};
template<typename T>
hhdyptr<T>& hhdyptr<T>::operator++() {//类外不可以简化模板类名hhdyptr hh = *this;//类内可以简化模板类名++* this;return hh;
}
//以关键字template开始，后跟模板参数列表
template <typename T>
class hhdy {public:typedef T value_type;typedef typename std::vector<T>::size_type size_type;//构造hhdy():data(std::make_shared<std::vector<T>>()){}hhdy(std::initializer_list<T> il):data(std::make_shared<std::vector<T>>(il)){}//元素数目size_type size() const{return data->size();}bool empty() const {return data->empty();}//增删元素void push_back(const T& t); void push_back(T&& t) {data->push_back(t);}void pop_back() {data->pop_back();}//元素访问T& back() {return data->back();}T& operator[](size_type idx) {if (check(idx,"out of range")) {return ( * data)[idx];}return back();}private:std::shared_ptr<std::vector<T>> data;bool check(size_type i, const std::string& msg) const {try {if (i >= size())throw std::out_of_range(msg);return 1;}catch (std::out_of_range& err) {std::cerr << err.what() << std::endl;return 0;}}
};template<typename T>
void hhdy<T>::push_back(const T& t) {data->push_back(t);
}1.2.2实例化
- 类模板实例化
- 一个类模板每个实例都形成一个独立的类。没有其他hhdy类的特殊访问权限。
hhdy<int> hh = { 1,2,3,4 }; //需要提供元素类型
- 类模板成员函数实例化
- 成员函数只有在被用到时才会实例化
hh.push_back(5);std::cout << hh.size() << std::endl;std::cout << hh[6]<< std::endl;
1.2.3类模板与友元
- 对于类与函数
- 类与友元各自是否是模板相互无关。
- 一个类可以将另一个模板的每个实例都声明自己的友元，或者限定特定的实例为友元。
- 在声明特定实例为友元前，需要进行友元类和友元函数的前置声明；将每个实例都声明为友元时不需要前置声明，此时友元声明中要使用与类模板本省不同的模板参数。
- 对于自己的类型参数，可以将模板参数声明为友元
//声明特定实例为友元前需要前置声明
template <typename T>class hhdy;
template <typename T>class xx;
template <typename T>
class xx{friend class hhdy<int>;
};
//将每个实例都声明为友元时不需要，友元声明中要使用与类模板本省不同的模板参数。
template <typename T>
class xx{friend template <typename C> friend class hhdy;
};
//可以将模板参数声明为友元。
template <typename T>
class xx{friend T;
};
1.2.4类模板类型别名
- 可以定义一个typedef引用实例化类：
typedef hhdy<int> ihhdy; - 可以通过using为类模板定义类型别名,可以固定一个或多个模板参数：
template<typename T> using twin = pair<T,T>;
twin<int> pairs; //pair<int,int>
template<typename T> using partNo = pair<T,unsigned>;
partNo<int> xx; //pair<int,unsigned>
1.2.5类模板静态函数
- 类模板可以声明static成员，对于任意给定类型
X,FOO<X>类型对象共享静态对象和函数。
class xx {public:xx() = default;xx(T t):num(t){}static void prt() {std::cout << "999" << std::endl;}T num;static std::size_t ctr;
};
template<typename T>size_t xx<T>::ctr = 0; //将static数据成员也定义为模板int main(){xx<int> xx1，xx2; //共享static成员，实例化xx<int>类及内部静态成员xx2.prt();xx<int>::prt();//通过类模板访问要说明类的类型参数std::cout << xx<int>::ctr << std::endl;std::cout << xx2.ctr << std::endl;
}
1.3模板参数
- 作用域：模板参数明可用范围实在其声明之后，至模板声明或定义结束之前。模板参数会隐藏外层作用域中声明的相同名字。模板内不能重用模板参数名。
- 声明：声明必须包含模板参数，声明与定义的模板参数名不必相同。但必须有相同数量和种类的参数。
- 类型成员：作用域运算符（::）可以访问static成员和类型成员。对于模板类型参数
T，当遇到T::size_type*p时，会不知道size_type是类型成员还是static成员，要通过关键字typename加以区分。
此时有两种解释：
- 1.T::size_type 类型的p指针->
typename T::size_type *p- 2.静态成员size_type乘以p->
T::size_type*p
- 默认模板实参：可以为函数和类模板提供默认实参：
//函数
template<typename T,typename F = std::less<T>>
bool compare(const T& v1, const T& v2, F f = F()) {return f(v1, v2);
}
//类模板
template<typename T = int>class A {};
A<> b; //默认A<int>
template<typename U>class A;
template<typename T = int>class A {public:typedef size_t A_type;T calc(const T&, const T&);//不是典型例子typename A<T>::A_type capacity() {return A<T>::cap;}
private:static size_t cap;T t;
};
template<typename T> size_t A<T>::cap = 100;
template<typename T> T A<T>::calc(const T& a, const T& b) {//double T; //报错，重声明模板参数名称return a + b;
}
int main() {A<int> a;A<> b;std::cout << a.calc(1,2) << std::endl;std::cout << a.capacity() << std::endl;std::cout << compare(3,2) << std::endl;return 0;
}
1.4成员模板
- 类可以包含本身是模板的成员函数。
- 成员模板不能是虚函数。
1.4.1非模板类的成员模板
//默认删除器
class DebugDelete {public:DebugDelete(std::ostream&s = std::cerr):os(s){}template<typename T>void operator()(T* p)const { //成员函数模板os << "delete unique_ptr" << std::endl;delete p;}
private:std::ostream& os;
};int main() {//用来删除堆上指针double* p = new double;DebugDelete d;d(p);int* ip = new int;DebugDelete()(ip);//可以用做unique_ptr删除器,unique_ptr的析构函数会调用DebugDelete的调用运算符进行析构。std::unique_ptr<int, DebugDelete> p1(new int, DebugDelete());*p1 = 2;std::cout << *p1 << std::endl;return 0; //unique_ptr在函数结束后会进行析构并调用DebugDelete()
}
1.4.2类模板的成员模板
- 类和成员各自有自己独立的模板参数
template<typename T>
class A {public:template<typename U>U calc(const U&, const U&);
};
//类模板外定义成员模板
template<typename T>
template<typename U>
U A<T>::calc(const U& a, const U& b) {return a + b;
}
intmain(){A<int> a;std::cout << a.calc(1,2) << std::endl; //3,推断为calc<int>return 0;
}
1.5模板实例化控制
- 通过显式实例化来避免实例化相同模板的额外开销
extern template declaration; //实例化声明
template declaration; //实例化定义
extern模板声明表示在程序其他位置存在实例化的非extern声明或定义，它不会在本文件中生成实例化代码。
对于一个给定实例化版本，可以有多个extern声明，但必须只有一个定义。
extern声明必须出现在使用此实例化版本代码之前。
两个程序必须链接在一起
//templatebuild.cc,函数非extern声明，进行实例化
template int compare(const int&,const int&);
template class Blob<string>;
//Application.cc，函数extern声明，不实例化
extern template class Blob<string>;
extern template int compare(const int&,const int&);
Blob<string> sa1,sa2;
int i = compare(1,2);
1.6 效率与灵活性
以智能指针里shared_ptr和unique_ptr为例：
| 区别 | shared_ptr | unique_ptr |
|---|---|---|
| 管理保存指针的策略 | 给予共享指针所有权的能力 | 独占指针 |
| 重载默认删除器的方式 | 创建或reset指针时传递给它一个可调用对象 | 必须以显式模板实参的形式提供删除器类型 |
| 删除器绑定方法 | 运行时绑定，能直接访问，保存一个指针或封装了指针的类 | 编译时绑定，删除器直接绑定在unique_ptr对象中 |
| 工作 |
del？del(p):delete p;
|
del(p);
|
| 优势 | 运行时绑定，重载删除器更方便 | 编译时绑定，避免间接调用删除器的运行时开销 |
2 模板实参推断
模板实参推断：从函数实参来确定模板实参的过程被称为模板实参推断。
2.1类型转换
2.1.1 隐式转换
- 对于类型转换，除以下转换外，其他转换无法应用于函数模板：
- 顶层cosnt无论是在形参还是实参中都会被忽略；
- 可以将一个非const对象的引用或指针传递给一个const的引用或形参。
- 可以将数组和函数转化为数组指针和函数指针。
- 编译器通常不对实参进行类型转换，而是生成一个新的模板。
- 如果希望对函数实参进行正常类型转换，可以将函数模板定义为两个类型参数：在使用时要求实参类型必须兼容。
- 对于不是模板参数的函数参数会进行正常的类型转换
template<typename T>T fobj(T t1, T t2) { //拷贝模式return t1 ;
}
template<typename T>T fref(const T& t1, const T& t2) { return t1 ;
}
template<typename T，typename K>bool fcom(T t1, K k1) { //拷贝模式return t1>k1 ;
}
template<typename T>bool fcompare(T t1, T t2) { //拷贝模式return t1>t2 ;
}int main() {std::string s1("a value");const std::string s2("another value");std::cout<<fobj(s1, s2)<<std::endl; std::cout << fref(s1, s2) << std::endl; //s1可以转化为const形式int arr1[4] = { 1,2,3,4 };int arr2[6] = { 1,2,3,4,5,6 };std::cout << fobj(arr1, arr2) << std::endl; //输入变为数组指针//std::cout << fref(arr1, arr2) << std::endl; //错误，数组类型不匹配long lng = 1024;fcom(lng,1024); //正确fcompare(lng,1024); //错误，不知道转换为<long, long>还是<int, int>return 0;
}
2.1.2 显式转换
- 当编译器无法推断出模板实参类型时，允许用户控制模板实例化。
- 例1：函数返回类型与参数类型列表中任何类型都不相同时。
template<typename A,typename B,typename C> A sum(B b,C c);
- 此时需要为类型A提供显式模板实参
auto val3 = sum<long long>(i,lng);
- 显式模板实参按从左到右的顺序与对应模板参数匹配
template<typename A,typename B,typename C> C sum(A a,B b);
auto val = sum<int>(i,lng); //错误，不能推断A类型
auto val2 = sum<int,long,long long>(i,lng); //正确
- 例2：显式指定实参的类型转换
template<typename T>bool fcompare(T t1, T t2) { //拷贝模式return t1>t2 ;
}
fcompare<int> (i,lng); //实例化fcompare<int,int>
2.1.3 尾置返回类型
- 对于一些特殊情况，需要尾置返回类型。比如处理迭代器并返回迭代器类型时，由于迭代器类型在参数列表中，所以可以使用尾置返回类型返回。
template<typename It>
auto fcn(It beg,It end) -> decltype(*beg) //使用尾置返回类型
{return *beg;
}
//使用
std::vector<int> vi = { 1,2,3,4 };
auto& i = kfcn(vi.begin(), vi.end()); //int&
- 进行类型转换的标准库模板类：希望编写一个函数，返回的是元素值而不是引用。进行迭代器操作时，生成的都是元素的引用。此时可以使用标准库类型转换。
- 头文件：
#include<type_traits>
//使用typename告知编译器type表示一个类型
template<typename It>
auto kfcn(It beg,It end) ->typename std::remove_reference<decltype(*beg)>::type
{return *beg;
}
//返回元素值拷贝
auto i = kfcn(vi.begin(), vi.end());
- 标准库模板中有一个名为type的public成员，表示一个类型。当不需要转换时，该类型时模板参数类型本身，否则是转换后的模板类型。
- 包括：解引用、加底层const、加左值引用、加右值引用、增删指针、变有符号/无符号、移维度等
2.1.4 函数指针
- 用一个函数模板初始化函数指针或为函数指针赋值时，编译器使用指针类型推断模板实参。
template<typename T> int kcompare(const T&, const T&);
//可以用函数指针指向kcompare的一个实例
int (*pf)(const int&, const int&) = kcompare;
//对于存在多个重载的函数指针，需要调用特定实例版本的函数指针，需要用显式模板调用
void func(int(*)(const string&,const string&));
void func(int(*)(const int&,const int&));
func(compare<int>);
2.1.5引用
2.1.5.1 左值引用
- 对于普通左值引用，只能传递给它一个左值
- 对于
const T&类型，可以传递给它任何类型的实参（对象、临时对象或字面值常量等）。
2.1.5.2 右值引用
- 对于右值引用（
T&&），可以传递任意类型实参。左值变为左值引用，右值变为右值引用，引用会进行引用折叠。
2.1.5.3引用折叠的两个例外规则
- 引用折叠只能应用于间接创建的引用的引用，如类型别名或模板参数
- 1.将一个左值传递给函数的右值引用参数，且此右值引用指向模板类型参数时，该实参为左值引用类型。
template<typename T> void A(T&&);
int i = 64;
A(i); //函数实参类型变为int&
const int ci = 5;
A(ci);//函数实参类型变为const int&
- 2.间接创造一个引用的引用，这些引用会形成折叠，成为普通的左值引用类型。对于右值引用的右值引用，会折叠为右值引用。
X& &, X& &&, X&& &都折叠成X&
X&& &&折叠成X&&
2.1.6 std::move（右值引用的函数模板案例）
- std::move定义：
//不论接收的是什么类型，返回一个右值引用
template<typename T>
typename std::remove_reference<T>::type&& move(T&& t) {return static_cast<std::remove_reference<T>::type&&>(t);
}
template <class _Ty>
_NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept { // forward _Arg as movablereturn static_cast<remove_reference_t<_Ty>&&>(_Arg); //去引用后加右值引用，返回一个右值
}
static_cast 强制将对象类型转换为type，也可以显式的将一个左值转换为右值引用。
2.1.7 转发
- 函数转发：函数需要将其一个或多个实参连同类型不变地转发给其他函数，转发时保持被转发函数的所有性质。
//翻转函数
template<typename F,typename T1,typename T2>
void flip(F f, T1&& t1, T2&& t2) {std::cout<<f(std::forward<T2>(t2), std::forward<T1>(t1)) << std::endl;
}
- 形参都是右值引用形式：实参既可以是左值又可以是右值,并且进行了参数绑定
- std::forward:头文件
#include<utility>，std::forward<T2>，返回实参类型的右值引用std::forward<Type>(arg);//使用Type作为forward的显式模板实参类型，实际类型从arg中推断。arg是右值时，Type是普通类型，forward<Type>返回Type&&；当arg是左值，Type是左值引用，返回类型是指向左值类型的右值引用，折叠后为左值引用。
template <class _Ty>
_NODISCARD constexpr _Ty&& forward(remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvaluereturn static_cast<_Ty&&>(_Arg); //返回右值引用（可能折叠）
}
template<typename K>K ff(K1&& t1, K2& t2) {return t1;
}
template<typename F,typename T1,typename T2>
void flip(F f, T1&& t1, T2&& t2) {//ff(t2, t1); //错误，因为t2作为右值表达式是个左值，不能传入右值，需要将t2从右值表达式转换为右值再传入ff函数，所以要使用std::forward函数。std::cout<<f(std::forward<T2>(t2), std::forward<T1>(t1)) << std::endl;
}
3函数重载与模板
- 函数模板可以被另一个模板或一个普通非模板函数重载
- 当有多个重载模板对一个调用提供好匹配时，选择最特例化的版本；
- 对于一个调用，如果一个非函数模板与一个函数模板提供同样好的匹配，选择非模板版本；
- 定义任何函数之前，要声明所有重载的函数版本。
#include<iostream>
#include<sstream>
#include<string>
//1
template<typename T>std::string debug_rep(const T& t) {std::ostringstream ret;ret << t;return ret.str();
}
//2
template<typename T>std::string debug_rep(T* p) {std::ostringstream ret;ret <<"poiter: " << p;if (p) ret << " " << debug_rep(*p);elseret << " null pointer"; return ret.str();
}
//3
std::string debug_rep(const std::string &s) {return '"' + s + '"';
}
//4
std::string debug_rep(char* p) {std::cout << "char" << std::endl;return debug_rep(std::string(p));
}
//5
std::string debug_rep(const char* p) {std::cout << "const char" << std::endl;return debug_rep(std::string(p));
}//声明
template<typename T>std::string debug_rep(const T& t);
template<typename T>std::string debug_rep(T* p);
std::string debug_rep(const std::string& s);
std::string debug_rep(char* p);
std::string debug_rep(const char* p);int main() {std::string s("hi");std::string* sp = &s;char strs[] = "hello world";std::cout << debug_rep(s) << std::endl;//可匹配1/3，最终匹配3std::cout << debug_rep(sp) << std::endl;//可匹配1/2，匹配到第2个版本std::cout << debug_rep(strs) << std::endl;//会匹配到2，但不对，要进行精确匹配（增加4）return 0;
}
4可变参数模板
4.1可变参数模板
- 可以使用initializer_list定义一个接受可变数目且具有相同类型的实参的函数，要想接收可变数目且实参类型不同，需采用可变参数模板。
- 可变参数模板是接受可变数目参数的模板函数或模板类。可变数目的参数被称为参数包。分为模板参数包和函数参数包两种。
- 用一个省略号来指出一个模板参数或函数参数表示一个包。
- 可变参数函数通常采用递归形式处理实参，为了种植地柜，还需要要定义一个非可变参数形式的print函数。
- 参数包可以进行大小获取（sizeof…）以及包扩展
#include<string>
#include<sstream>
#include<iostream>template<typename T,typename... Args>
void getsize(const T& t, const Args& ... rest) {std::cout << sizeof...(Args) << std::endl; //3，返回参数包中参数数目std::cout << sizeof...(rest) << std::endl;//3
}//需要定义/声明递归结束时的非可变参数版本防止无限递归
template<typename T> std::ostream& print(std::ostream& os, const T& t) {return os << t;
}
template<typename T,typename... Args> //扩展Args，扩展模板参数包
std::ostream& print(std::ostream& os,const T& t, const Args&... rest) { //扩展rest，扩展出一个有包种元素组成的，逗号分隔的列表，是函数调用生成实参列表if constexpr (sizeof...(rest) == 0) //c++17语法，按条件编译，有这一条就不需要非可变参数版本了return os << t;else {os << t << ", ";return print(os, rest...);}
}
int main() {int i = 0;double d = 3.14;std::string s = "hhdy";getsize(std::cout,i, d, 42, s);print(std::cout,i, d, 42, s)<<std::endl;return 0;
}
4.2转发参数包
- 组合使用可变参数模板和forward机制，实现实参不变的传给其他函数
- 例：emplace_back:在容器内存空间中直接构造一个函数，参数移动构造，是参数列表右值引用
class hhdy {public:friend std::ostream& print_hh(std::ostream& os, const hhdy& hh);hhdy(int n = 0,std::string str = "null"):i(n),s(str){}
private:int i;std::string s;
};
std::ostream& print_hh(std::ostream& os,const hhdy& hh) {os << hh.s << " " << hh.i;return os;
}
class hhdy_vec {public:friend std::ostream& print_hhv(std::ostream& os, const hhdy_vec& hhv);hhdy_vec(){ std::vector<hhdy> vh; }hhdy_vec(std::vector<hhdy> vii):vh(vii){}template<class... Args>void emplace_back(Args&&... args) {vh.emplace_back( std::forward<Args>(args)...);}
private:std::vector<hhdy> vh;};
std::ostream& print_hhv(std::ostream& os, const hhdy_vec& hhv) {for (auto hh : hhv.vh) {print_hh(os,hh)<<std::endl;}return os;
}
int main() {hhdy_vec hhv;hhv.emplace_back(60, "xx");print_hhv(std::cout,hhv);
}
5模板特例化
5.1模板特例化
- 当不能或不希望使用模板版本时，可以定义类或者函数模板的一个特例化版本。
- 特例化版本是模板的一个独立的定义
5.2函数模板特例化
- int类型特例化版本必须为模板中美每个模板参数提供实参
- 特例化时使用template<>,<>表示会为原模板所有模板参数提供实参
- 特例化版本的本质是一个实例，当同时存在可用的非模板版本、特例化版本和函数模板版本时，非模板版本>特例化版本>函数模板版本
- 模板及特例化版本应声明在同一个头文件中，所有同名模板声明应放在前面，然后是模板特例化版本。
template<typename T>
void test(T&& i) {std::cout <<"函数模板型版本test函数：" << i << std::endl;
}
template<>
void test(int&& i) {std::cout << "int类型特例化版本test函数：" << i << std::endl;
}
template<size_t n, size_t m>
int getcom(const char(&t1)[n] , const char(&t2)[m]) { //注意模板参数写法std::cout << "size_t类型特例化版本test函数：";return strcmp(t1, t2);
}
int main() {test(10);test("hh");
5.3类模板特例化
5.3.1类模板特例化
- eg：为标准库hash模板定义一个特例化版本（自定义类对象版本），使其能存储在无序容器中。
- 特例化hash类包括：
- 一个重载的调用运算符，接受一个容器关键字类型的对象，返回size_t。
- 两个类型成员，result_type以及argyment_type，调用运算符的返回类型和参数类型
- 默认构造函数和拷贝赋值运算符
- 为了将其定义在hash所在std命名空间内，需要打开std命名空间：
namespace std{} //关闭命名空间，没有分号
- 使用时hash值需要与自定义类模板的operator==运算符兼容
- 在自定义类模板的有文件中定义特例化版本
template<class T>class std::hash; //友元声明前
class hhdy {public:friend struct std::hash<hhdy>; //声明为友元以访问对象hhdy(int i, std::string s) :height(i), date(s) {}
private:int height;std::string date;
};
namespace std {//参考struct std::hash<double>;//template <>//struct hash<double> {// _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef double _ARGUMENT_TYPE_NAME;// _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef size_t _RESULT_TYPE_NAME;// _NODISCARD size_t operator()(const double _Keyval) const noexcept {// return _Hash_representation(_Keyval == 0.0 ? 0.0 : _Keyval); // map -0 to 0// }//};template<>struct hash<hhdy> {typedef size_t result_type;typedef hhdy argument_type;size_t operator()(const hhdy& hh)const {return hash<int>()(hh.height) ^ hash<std::string>()(hh.date);};};
}
5.3.2类模板部分特例化
- 本质：生成一个特例化类模板
- 部分特例化版本的模板参数列表是原始模板的参数列表的一个自己或一个特例化版本。
template<class T> struct remove_reference {typedef T type;
};
template<class T>struct remove_reference<T&>{typedef T type;
};
template<class T>struct remove_reference<T&&> {typedef T type;
};
5.3.3特例化类成员
- 可以特例化特定成员函数而不是整个模板
template<typename T>struct Foo{Foo(const T &t = T()):mem(t){}void Bar()T mem;
}
template<>
void Foo<int>::Bar{} //当为Foo<int>类时，成员函数Bar函数使用特例化版本进行不同操作
（十六）模板与泛型编程相关推荐
- OpenCV与图像处理学习十六——模板匹配
OpenCV与图像处理学习十六--模板匹配 一.模板匹配介绍 二.代码应用 一.模板匹配介绍 模板匹配是一种最原始.最基本的模式识别方法,研究某一特定目标的图像位于图像的什么地方,进而对图像进行定位. ...
- C++ Primer plus学习笔记-第十六章：string类和标准模板库
第十六章:string类和标准模板库 前言:这一章已经相当靠近全书的后面部分了:这一章我们会深入探讨一些技术上的细节,比如string的具体构造函数,比如适用于string类的几个函数,比如我们还会介 ...
- Web Hacking 101 中文版 十六、模板注入
十六.模板注入 作者:Peter Yaworski 译者:飞龙 协议:CC BY-NC-SA 4.0 模板引擎是允许开发者或设计师在创建动态网页的时候,从数据展示中分离编程逻辑的工具.换句话说,除了拥 ...
- 【Visual C++】游戏开发笔记四十六 浅墨DirectX教程十四 模板测试与镜面特效专场
本系列文章由zhmxy555(毛星云)编写,转载请注明出处. 文章链接: http://blog.csdn.net/zhmxy555/article/details/8632184 作者:毛星云( ...
- 十六.静态页面抽取模板 2021-03-31
十六.静态页面抽取模板 引言 模板标签之模板继承 静态模板文件:链接:https://pan.baidu.com/s/1eZKi4a5fBTmy-DwAQmr51w 提取码:8mmy django-- ...
- 苹果CMSv10首涂第十六套首款原创支持百度mip技术自适应视频模板
苹果CMSv10首涂第十六套首款原创支持百度mip技术自适应视频模板 首涂[第十六套]苹果CMSv10首款原创支持百度mip技术自适应视频模板 首款支持mip加速技术的模板,样式简洁速度快采用最新百度 ...
- 《Effective C++》 总结篇(模板与泛型编程)
条款四十一:了解隐式接口的和编译期多态 和面向对象编程的显示接口和运行期多态不同, 泛型编程更多是隐式接口和编译期多态. #include <iostream> using namespa ...
- 来自极客标签10款最新设计素材-系列十六
本周我们推荐来自极客标签社区带来的10款免费设计素材,大家可以在这里免费下载你需要的内容.如果你也有更好的作品,欢迎分享到社区中来,在得到帮助的同时,也能与更多人分享来自你的作品. 免费图标:扁平风格 ...
- 【OpenCV十六新手教程】OpenCV角检测Harris角点检测
本系列文章由@浅墨_毛星云 出品.转载请注明出处. 文章链接: http://blog.csdn.net/poem_qianmo/article/details/29356187 作者:毛星云(浅墨) ...
最新文章
- 《评人工智能如何走向新阶段》后记（再续3）
- [Linux]学习笔记（4）-su及passwd的用法介绍
- MySQL 8.0 首个自适应参数横空出世
- canvas rotate 累加旋转_【教研动态】音乐活动中，使用材料累加情境的适宜性
- 通过IDEA查看jar包中的依赖关系
- python 多个列表_Python同时迭代多个列表
- 数学史思维导图_【学科活动】思维导图展风采，数学文化提素养——庆云县第四中学（北校区）四年级数学组活动小记...
- [软件工程学习笔记]浅谈敏捷开发
- 敏捷项目管理流程-Scrum框架最全总结
- Spring Security HttpSecurity.authorizeRequests
- @程序员，欠下的技术债怎么还？
- Mybatis 与java 类型 对应表
- .sh 编译 java_build-java.sh
- Hive with as语法
- js 获取select 中option 的个数
- JRebel过期激活
- 利用python第三方库过抖音小店后台滑块
- 5个最优秀的Java和C#代码转换工具
- Podfile语法参考（译）
- 为视频增加中文字幕---Amazon Transcribe