简介
元编程是更高层次的抽象，对代码进行编程。把程序甚至自己作为输入数据来处理，比如py的虚拟机就是元程序，它处理py的代码把其转换成py的虚拟机指令。称py为输入语言domain language，称输出的语言字节码为host language
根据是否使用了domain-language将元编程分为2类
- 使用domain language的meta programming,普通程序和元程序是分离的
- 直接使用host language来实现元编程，通常通过编译机制，将元编程代码生成逻辑代码，然后和其他的逻辑代码合并在一起，看起来像“逻辑代码自己改写自己”，c++的TMP属于这种。
c++模板元编程
模板通过编译器生成其他c++代码，然后和其他的c++代码一起编译
template
struct binary {
//static constexpr int value = binary::value << 1 | N % 10;
enum {
value = binary::value << 1 | N % 10,
};
};
template<>
struct binary<0> {
enum {
value = 0,
};
};
//证明编译期代码1
static char array[binary<101>::value];
//证明编译期代码2
template
struct A{};
A::value> a;
小技巧c++中 如果包含static关键字的东西，大概率是编译期确定的，反正dynamic关键字通常是运行时确定的，比如dynamic_cast,dynamic
c++模板已经被证明是图灵完备的了，意味着通过计算机表达的任何计算都可以用tmp来实现
学习tmp的原因
可以编译期计算，提升运行时效率，通常会导致编译期时间变长，以及编译出的文件大小变大
-
可以针对类型做计算，由于c++缺少自省机制
if(typeof(var) == int){}else{} //psedo code -
tmp可以让代码变得简单优美
py::class_("m","Student") .def (py:init ()) .def ("set_name",&Student::set_name) tmp应用比较广泛且是未来趋势，比如asio，比如boost
模板基本概念
可以声明5中不同的模板
- template
struct class_tmpl; - template
void func_tmpl(T ); - template
var_tmpl;//变量模板 c++ 14 - template
using alias_tmpl = T; //别名模板 c++11 - template
concept no_constrant = true; //c++ 20
前3个模板都可以用于定义，后两个不需要定义,不产生运行时的实体
- template
struct class_tmpl{} - template
void func_tmpl(T arg){} - template
var_tmpl = T(3.14);
c++14中有范型lambda，但是不是模板，是普通的lambda，但是它的operator()函数是个模板
auto glambda = [](T a,auto && b){return a 模板形参和实参
template struct NoneTypeTemplateParameter {}; //非类型形参
template struct TypeTemplateParameter {}; //类型模板形参
template typename tmpl> struct TemplateTemplateParameter {}; //模板模板形参
//应用
NoneTypeTemplateParameter<1>();
TypeTemplateParameter();
TemplateTemplateParameter();
非类型模板形参只接受“结构化类型常量”
- 整形 int char，long等
- enum类型
- 指针和左值引用
- 浮点类型 以及 字面常量 literal class type (c++ 20 后才支持)
template void foo() {std::cout<(); // 0.1f
foo(); // error 模板实参需要编译期可以推导
模板模板形参 只接受 类模板 或者类的别名模板作为实参，不接受函数模板，且形参和实参的模板参数匹配
template typename Tmpl>
struct S {};
template void foo(){};
template struct Bar1{};
template struct Bar2{};
S(); //error
S();//ok
S();//error 形参和实参的模板参数不匹配
变参形参列表 可以接受多个或者0个参数，参数可以是非类型的常量，可以是类型，也可以是模板。 变长的部分一定要在参数的最后
template struct VariadicTemplate1 {};
template struct VariadicTemplate2 {};
template typename... Args> struct VariadicTemplate3 {};
VariadicTemplate1<1,2,3>();
VariadicTemplate2();
VariadicTemplate3<>();
VariadicTemplate3();
//可以设置默认模板参数
templat struct WithDefaultTemplate {};
模板的实例化，指的模板生成具体函数或者变量的过程
Implicit 实例化
//t.hpp
t
//t.cpp
//按需实例化，隐式实例化
#include "t.hpp"
foo(1);
foo(2);
std::function func = &foo(int);
//显式实例化 告诉编译器去实例化这个模板 但是现在不用
tempate void foo(int);
tempate void foo<>(int);
tempate void foo(int);
使用模板时，编译器根据实参生成对应的代码，插入个特定的位置，然后把代码插入，这个位置称为POI（point of instantiation）,所以在同一个编译单元里，编译器一定要能看到模板的定义，最常见的做法，模板定义放在头文件，然后在cpp文件include 这个头文件来获取模板的定义，这个也被称为包含模型。
包含模型的问题，
- 不同编译单元，相同模板会被实例化多次，从而产生多个相同的类型，函数或变量，会导致链接时重定义的问题
- 浪费编译时间
//主流解决方案式对模板生成的对象，添加个特殊标记，链接器在链接时，对含有这些特殊标记的符号做特殊处理。比如gnu下模板生成的符号都会被标记成弱符号
//或者显式实例化声明 c++ 11之后
extern tempate void foo(int);
extern tempate void foo<>(int);
extern tempate void foo(int);
模板实参推导
template
void foo(T,T) {};
foo(1,2);//#1 T deduced 1 等于foo
foo(1,2.0);//1st arg deduced int,2st deduce double ,推导失败
c++17后 可以通过类模板的构造函数推导类模板
template
struct S {S(T,int){};};
S s(1,2); //T deduced int
std::pair(1,2.0f); //before c++17
std::make_pair(1,2.0f);//before c++17
std::pair(1,2.0f);//since c++17
模板特化
模板特化允许替换部分或者全部形参，并且定义个对应替换的模板实现，定义一个替换全部的形参的特化称为全特化，定一个替换部分形参的特化称为偏特化，非特化的原始模板称为主模板
template void foo(T,U){} //主模板
template<> void(int,float) {} //全特化
//需要注意的是函数模板不能偏特化，只有类模板和变量模板才可以,虽然不能偏特化，但是可以通过函数的重载实现类似的效果
template struct S{} //#1 主模板
template struct S{} //#2 偏特化
template<> struct S{} //#3 全特化
//模板实例化的时候，编译器会从所有的特化版本中选择最匹配的特化版本来做替换，如果没有任意特化进行匹配，就会选择主模板来匹配
S(); #2
S(); #3
S(); #1
//注意不要混淆模板的全特化和模板显式实例化 长得非常像，区别仅仅多了个<>
template void fun(int,int); //模板显式实例化
template<> void fun(int,int).; //模板全特化
//模板的实例化的结果就应该是个全特化，有时候称模板生成的结果为隐式特化，本节中讨论的机制为显示特化。所以不同环境下“specialization” 未必就指的本节讨论的特化
函数模板重载
函数模板可以重载，并且可以和普通的函数一起重载，使用重载可以实现和偏特化类似的效果。c++模板或者函数只要签名不同，就可以重载。
template void foo(T) {};#1
template void foo(T*) {};#2
template int foo(T) {};#3
template void foo(T) {};#4
template void foo(T,U) {};#5
template void foo(T,U) {};#6
void foo(int) {}; #7
void foo(float,int) {}; #8
//由于有模板实参推导机制，所以函数模板可以和普通函数一起重载
//call
foo(1); //#7
foo(new int(1));//#2
foo(1.0f,1); //#8
foo(1,1.0f);//#5
foo(1.0,1);//errro ambiguous
TMP特点
- 使用模板当成函数（metafunction）,模板参数当做函数参数，static 成员当作函数返回值
- 使用模板实例化来调用metafunction
- 使用特化或者重载来实现分支的选择
- 使用递归来实现循环
- 由编译器驱动
- 处理的数据是常量 或者 类型
TMP运用
例子1 is_reference
std::cout<::value<::value<::value< struct IS_Reference{ static constexpr bool value = false; };
template struct IS_Reference{ static constexpr bool value = true; };
template struct IS_Reference{ static constexpr bool value = true;};
//编译器怎么判断一个特化能不能匹配的呢，重新记录下参数名称
template struct IS_Reference{ static constexpr bool value = false; };
template struct IS_Reference{ static constexpr bool value = true; };
template struct IS_Reference{ static constexpr bool value = true;};
//对于
IS_Reference::value 这个实例化
带入1号模板 T1 = int&
带入2号模板 T1 = T2& = int& 推导出 T2 = int ok
带入3号模板 T1 = T2&& = int& 推导失败
//判断特化能不能匹配
1.先确定所有的模板实参
2.带入到特化中
3.反向推导特化的形参
remove_reference
template void foo(T a){a = a +1;}
int i = 0;
foo(i); //pass lvalue ref
foo(1);//pass rvalue ref
//但是我们希望按值去传递 最好去除引用
//Remove_reference实现
template struct Remove_reference{ using type = T; };
template struct Remove_reference{ using type = T; };
template struct Remove_reference{ using type = T; };
//之所以要加typename 编译器处理这句时，无法知道这个是个类型，所以需要显式的制定typename
template void foo(typename Remove_reference::type a){ a = a +1;}
metafunction 规定的概念
接收常量和类型作为参数，返回类型和常量当结果
- metadata
- 类型和常量
- 常量被模板包起来被称为“none-type metadata”
- metafunciton
- 是编译期间的“函数”，接收metadata作为参数，并且返回metadata作为结果
//type metadata
int;
struct S{};
//none-type metadata
template struct bool_ {static constexpr bool value = b;}
//metafunciton
template struct is_reference{using type = bool_;};
template struct is_reference{using type = bool_;};
template struct is_reference{using type = bool_;};
//典型的none-type metadata
template struct intergral_constant {
static constexpr T value = v;
using value_type = T;
using type = intergral_constant;
constexpr operator T() const noexcept {return value;}
constexpr T operator()() const noexcept {return value;}
};
//alias
template using bool_constant = intergral_constant;
using true_type = bool_constant;
using false_type = bool_constant;
所以is_reference实现可以变成
template struct ISReference{ using type = false_type; };
template struct ISReference{ using type = true_type; };
template struct ISReference{ using type = true_type;};
std::cout<::type::value;
std::cout<::type();
std::cout<::type()();
public继承是个比较容易的方式去使用另外一个metafunction
template struct ISReference : public false_type {};
template struct ISReference: public true_type {};
template struct ISReference: public true_type {};
//特化来做选择分支
template struct ISIntOrRefence: public ISReference {};
template<> struct ISIntOrRefence:public true_type {};
为了方便，会采用两种方式来简化
- 使用别名
//变量模板
template
inline constexpr bool is_reference_v = ISIntOrRefence::value;
//别名模板
template
using remove_reference_t = typename remove_reference::type;
std::cout<> << std::endl;
2.使用struct替代class,默认继承是public
template struct ISReference : false_type {};
template struct ISReference: true_type {};
template struct ISReference: true_type {};
例子1 type_identiy
template struct type_identiy {using type = T;};
//一行写metafunction 可以把类的定义写到一行中
template struct remove_reference :type_identiy{};
template struct remove_reference :type_identiy{};
template struct remove_reference :type_identiy{};
例子2 多形参is_same
//none-type metadata
template struct bool_ {static constexpr bool value = b;};
using false_type = bool_;
using true_type = bool_;
template struct is_same_v: false_type{};
template struct is_same_v:true_type {};
//编译期RTTI
int i;
is_same_v::value
通过is_same实现分支逻辑
template
int foo(T v) {
//if 是编译期间的语句
//所以要替换成 if constexpr (is_same_v)
if (is_same_v) {
return v; //不能从std::string 转换到 int
}
else if (is_same_v) {
return std::stoi(v);
}
}
foo(std::string("1"));
多形参is_one_of
template struct is_one_of: bool_constant::value || is_one_of::value>{};
template struct is_one_of:is_same_v{};
//运行时 if判断是短路求值，判断一个成功后，就不会继续比较了
//但是编译期 短路求值不生效的，会继续展开
//使用别名
template
using is_integral = is_one_of;
模板模板形参
std::cout<::value< li;
std::vector vi;
std::cout<::value<,std::list>
//模板实参 Inst = std::list Tmpl = std::list
//实参带入特化 Tmpl = std::list,Tmpl = std::list
//推倒 针对第一个推倒，Tmpl = std::list,Args... = float
//对于第二个推倒 Tmpl = std::list ,ok
例子2 条件语句
//编译期if
template struct type_identiy {using type = T;};
template
struct conditianal: type_identiy{};
template
struct conditianal: type_identiy{};
template
struct conditianal: type_identiy{};
template struct is_one_of : conditianal::value,true_type,is_one_of> {};
template struct is_one_of : conditianal::value,true_type,false_type>{};
std::cout<::type::value << std::endl;
例子3 处理数组