c++之说_12|模板

关于模板，至少我们要先了解几个概念

一：函数模板

二：类模板

三：模板特化

四：形参参数包

模板覆盖的东西太多我目前也不了解太多

函数模板语法

template<typename 类型名,typename 类型名,typename ...多参包类型名> 
//内部的typename可写多个 有时我们可能会看到 这里会写 class 意思大概是差不多的返回值 函数名(){};
如template<typename arg, typename ...args>
void set(arg s, args... d)
{val = s;base::set(d...);
};

这里我们可以看到 template<typename arg, typename ...args>

模板形参类型有 arg 和 args 形参包

arg 自然就代表可接受一个参数类型，

而args 形参包也叫变参参数包可接受多个参数

当然也有要求

一：

模板形参必须可推导，显示实例化也属于可推导

二：

有显示实例化当然也有隐式实例化

但隐式实例化有个要求

函数参数中必须可推导模板形参

如

template<typename arg, typename ...args>
void set(arg s, args... d)
{val = s;
};

模板形参在函数参数中直接用到了

可如此调用  这叫隐式实例化
set(10,'g',50,100); //arg = int   args = {char,int,int}这叫显示实例化
set<int,char,int,int>(10,'g',50,100); //arg = int   args = {char,int,int}

你会说我们要是在函数参数中没一一使用到模板形参怎么办？

template<typename Obj,typename arg, typename ...args>
void set(arg s, args... d)
{Obj c(s,d...);
};

自然就要显示实例化了注意必须可推导

set<obj_2>(10, 100);
// Obj = obj_2   agr = int  args ={int}

看就显示实例化了没用到的 Obj 模板形参我们人看上去也是可推导的

编译器是人写的所以逻辑也是有些符合我们的思维的

函数特化有两种

偏特化（部分特化）

全特化

说实在的我也不太懂我只能把我懂的部分说一下

首先我们先看看函数模板的偏特化与全特化

//主模版
template<typename Obj,typename arg, typename ...args>
void set(arg s, args... d)
{Obj c(s,d...);
};//特化版本   args* 形参包中 全为 指针类型
template<typename Obj, typename arg, typename ...args>
void set(arg* s, args*... d)
{Obj c(d..., s);
}//特化版本  Ret(*s)(a...)  非成员函数的函数指针
template<typename Obj, typename Ret,typename ...a,typename ...args >
void set(Ret(*s)(a...), args* ... d)
{Obj c((*d)..., s());
}//全特化   
template<>
void set<obj_2,float,float>(float v, float d)
{obj_2 c(d, v);
}//全特化
template<>
void set<obj_2>(float v, float d,char k)
{obj_2 c(d, v);
}

这里有个叫主模版的函数模板用特化就必须得需要主模版什么叫主模板？

我的理解中是函数模板最基本的哪个

比如上文

template<typename Obj,typename arg, typename ...args>
void set(arg s, args... d)
{
Obj c(s,d...);
};

这个模板可以容纳下面几个特化出来的函数参数的样子

比如指针类型非成员函数的函数指针类型成员函数的函数指针类型

也就是说它更加全面

你说都更加全面了我为什么还有特化

这是为了处理不同的情况嘛就和函数重载时处理不同情况一样

比如


int geti()
{return 50;
}int b = 10, b2 = 100;
set<obj_2>(&b,&b2);
/*
调用的特化版本是
template<typename Obj, typename arg, typename ...args>
void set(arg* s, args*... d)
{Obj c(d..., s);
}
*/set<obj_2>(&geti, &b2);
/*
调用的特化版本是
template<typename Obj, typename Ret,typename ...a,typename ...args >
void set(Ret(*s)(a...), args* ... d)
{Obj c((*d)..., s());
}*/set<obj_1>(0.5f, 5.3f);
/*
调用主模板版本
template<typename Obj,typename arg, typename ...args>
void set(arg s, args... d)
{Obj c(s,d...);
};*/set<obj_2>(0.5f, 5.3f,'p');
/*
调用的特化版本是
template<>
void set<obj_2>(float v, float d,char k)
{obj_2 c(d, v);
}*/set<obj_2>(0.f);
/*
调用主模版
template<typename Obj,typename arg, typename ...args>
void set(arg s, args... d)
{Obj c(s,d...);
};*/

有人可能看到有些特化怎么模板形参比主模版还多

template<typename Obj, typename Ret,typename ...a,typename ...args >
void set(Ret(*s)(a...), args* ... d)
{Obj c((*d)..., s());
}

这就是模板特化的一部分特性注意特化版本的模板形参与主模版的模板形参并无瓜葛

就算他们是一样的名字

但是实则是有一定要求的

比如

//主模板
template<typename Obj, typename arg>
void set1(arg c) { Obj c{}; };//全特化
template<>
void set1<obj_2,float>(float c) { obj_2 bc{}; };//错误特化版本  
template<>
void set1<obj_2,int,char>(int c) {};
/*这里我们注意到了, set1<obj_2,int,char>  有三个模板实参 而 我们的主模板只需要 两个模板实参  这就是要求：  不能大于主模版要求的模板形参数目*///错误特化版本   与上述一样   
template<>
void set1<obj_2>(int c,char b) {};

和函数重载很类似的规则

有人会问了那你第一种怎么可写好多个模板实参？

注意主模版哦

template<typename Obj,typename arg, typename ...args>
void set(arg s, args... d)
{Obj c(s,d...);
};

一眼上去三个模板形参但是我们最后是个模板形参包啊

不限个数的啊超过两个的形参统统进入形参包

这里可能有少年提出这样的写法

template<typename arg, typename ...args>
void set<obj_2>(arg s, args... d)
{obj_2 c(s,d...);
};

看着嗯..... 我就特化处理这个obj_2类型的

不过可惜这样写法是错误的

注意右边的编译输出错误

好了函数模板的特化说完了

---------------------------------------------------

现在我们来看看类模板

上模板

//主模版
template<typename tp>
struct t1
{
};//特化版本
template<typename Ret,typename Clss,typename ...Args>
struct t1 <Ret(Clss::*)(Args...)>
{using F = Ret(Clss::*)(Args...);t1(F fptr):ptr(fptr) {};F ptr;
};int main()
{t1<decltype(&obj_2::gets)> b(&obj_2::gets);return 0;
}

和函数模板特化差不多

类模板可通过构造函数的参数推断模板形参

template<typename tp>
struct t1
{using type = tp;t1(tp p) :tpo(p) {};tp tpo;
};template<typename Ret,typename Clss,typename ...Args>
struct t1 <Ret(Clss::*)(Args...)>
{using F = Ret(Clss::*)(Args...);t1(F fptr):ptr(fptr) {};F ptr;
};int main()
{t1<decltype(&obj_2::gets)> b(&obj_2::gets);t1 b = t1(&obj_2::gets);//特化版本 struct t1 <Ret(Clss::*)(Args...)>// F = int(obj_2::*)(int,int,char);t1(obj_2()); // 推断的是主模版  tp = obj_2return 0;
}

类模板可以弥补我们之前函数模板的遗憾

template< typename tp>
struct t2<obj_2,tp>
{t2(tp p):op(p) {}tp op;obj_2 d;};

它可以这样特化

但是又有可惜的事情了


t1 b3 = t1(obj_2()); //ok
auto c =    t2<obj_2,decltype(b3)>(b3); //ok  template< typename tp> struct t2<obj_2,tp>auto c2 = t2<obj_2>(b3); // error  可惜不可以这样调用  至少我是能看出来 应该可以推导

template<typename obj,typename tp>
struct t2
{using type = tp;t2(obj* oj,tp p) :ptr(oj), tpo(p) {};obj* ptr;tp tpo;
};//main 中t1 b = t1(&obj_2::gets);
t1 b3 = t1(obj_2());
auto c3 = t2(&b, &b3);//可以

对了忘记说一件事了

形参包我们通过特化给它拆开

//主模版
template<typename ...T>
struct Tuple_text {};//特化
template<>
struct Tuple_text<>
{void set() {};
};//特化
template<typename Ty1, typename ...Ty2>
struct Tuple_text<Ty1, Ty2...> :public Tuple_text<Ty2...> {Ty1 val;using base = Tuple_text<Ty2...>;Tuple_text() {}template<typename arg, typename ...args>Tuple_text(arg a, args... d) :val(a), base(d ...) {}template<typename ...arg>void set(arg... args) {};template<>void set<>() {};template<typename arg, typename ...args>void set(arg s, args... d){val = s;base::set(d...);};base& get(){return *this;}
};

这是今天学习到的 c++元组的类似做法

这里最关键的地方就是

template<>
struct Tuple_text<>
{void set() {};
};template<typename Ty1, typename ...Ty2>
struct Tuple_text<Ty1, Ty2...> :public Tuple_text<Ty2...>
{Ty1 val;
using base = Tuple_text<Ty2...>;Tuple_text() {}
template<typename arg, typename ...args>
Tuple_text(arg a, args... d) :val(a), base(d ...) {}}

没想到吧我们的构造函数都能模板

这个有点复杂

我们展开看看 C++ Insights (cppinsights.io) 这个网站可以展开模板

#include <cstdio>//主模板
template<typename ... T>
struct Tuple_text
{
};//特化
template<>
struct Tuple_text<>
{inline void set(){}};//以下都为特化  实例化后其实也就是特化
template<>
struct Tuple_text<long> : public Tuple_text<>
{long val;using base = Tuple_text<>;inline Tuple_text();template<>inline Tuple_text<long>(long a): Tuple_text<>(), val{a}{}};template<>
struct Tuple_text<float, long> : public Tuple_text<long>
{float val;using base = Tuple_text<long>;inline Tuple_text();template<>inline Tuple_text<float, long>(float a, long __d1): Tuple_text<long>(__d1), val{a}{}};template<>
struct Tuple_text<char, float, long> : public Tuple_text<float, long>
{char val;using base = Tuple_text<float, long>;inline Tuple_text();template<>inline Tuple_text<char, float, long>(char a, float __d1, long __d2): Tuple_text<float, long>(__d1, __d2), val{a}{}};template<>
struct Tuple_text<int, char, float, long> : public Tuple_text<char, float, long>
{int val;using base = Tuple_text<char, float, long>;inline Tuple_text();template<>inline Tuple_text<int, char, float, long>(int a, char __d1, float __d2, long __d3): Tuple_text<char, float, long>(__d1, __d2, __d3), val{a}{}};int main()
{Tuple_text<int, char, float, long> c = Tuple_text<int, char, float, long>(100, 'o', 6.0F, 500L);return 0;
}

注意main 函数里

我们看到这是一系列的继承关系

我们去vs 看看内存布局