c++之说_13|模板 折叠表达式
折叠表达式 可以通过形参包的的实际参数（不是类型） 展开式子
这是这里说的几种 实际上并还有一些写法
先介绍这几种吧
#include <cstdio>
template<typename T,T... n>
struct integer_sequence
{
T val;
};
template<int idx,typename _Tulp>
int get(_Tulp& t)
{
return 0;
}
template<typename Ret,typename ...T>
using b = Ret(*)(T...);
b<void,int,int,int,int> _fun;
template<typename ...T>
void getc(T...)
{
}
template<typename T, T... ints>
auto call(integer_sequence<T, ints...> int_seq)
{
T _tuple;
//return getc((get<ints>(_tuple))...);
//return getc(get<ints>(_tuple)...);
//return ((get<ints>(_tuple),...));
//return (ints||...);//一元右折叠
//return (...,ints);//一元左折叠
//return ((5*10)+...+ints);//二元左折叠
//return (ints+...+(5*10));//二元右折叠
}
template<typename ...T>
auto call(T* ... c)//integer_sequence<T*, ints...> int_seq)
{
//return (c -> h,...);
//return (*_fun)(c -> h...);
return (*_fun)( [&](){return c->h; }()...);
// return (c&&...&&0);
}
template<typename T>
struct jk
{
T h;
};
int main()
{
jk<int> b;
b.h = 10;
call(&b,&b,&b,&b);
call(integer_sequence<int, 0,1,2,3>());
}return (ints||...);//一元右折叠
//return (...,ints);//一元左折叠
// return ((5*10)+...+ints);//二元左折叠
//return (ints+...+(5*10));//二元右折叠
调用处 call(integer_sequence<int, 0,1,2,3>());
我们先看一元右折叠
return (ints||...);//一元右折叠
template<>
bool call<int, 0, 1, 2, 3>(integer_sequence<int, 0, 1, 2, 3> int_seq)
{
int _tuple;
return static_cast<bool>(0) || (static_cast<bool>(1) || (static_cast<bool>(2) || static_cast<bool>(3)));
}
//实例化后是如此
0||
( 1 || ( 2 || 3 )
)
是的外围没有小括号了
一元左折叠
return (...,ints);//一元左折叠
template<>
int call<int, 0, 1, 2, 3>(integer_sequence<int, 0, 1, 2, 3> int_seq)
{
int _tuple;
return ((0 , 1) , 2) , 3;
}
这个清楚多了二元左折叠
return ((5*10)+...+ints);//二元左折叠
template<>
int call<int, 0, 1, 2, 3>(integer_sequence<int, 0, 1, 2, 3> int_seq)
{
int _tuple;
return ((((5 * 10) + 0) + 1) + 2) + 3;
}二元右折叠
return (ints+...+(5*10));//二元右折叠
template<>
int call<int, 0, 1, 2, 3>(integer_sequence<int, 0, 1, 2, 3> int_seq)
{
int _tuple;
return 0 + (1 + (2 + (3 + (5 * 10))));
}好了简单的折叠式子给了
现在我们来看看有点不一样的
----------------------------------------------------
return getc( ( get<ints>(_tuple) )... );
比如这里 我们能看出想法
要根据 形参包实际的参数 ints 去调用并 铺开成为
函数 getc 的参数
如
ints = {0,1};
return getc( (get<0>(_tuple)) , ( get<1>(_tuple)) );实际上展开呢？
call(integer_sequence<int, 0,1,2,3>());//调用处
template<>
void call<int, 0, 1, 2, 3>(integer_sequence<int, 0, 1, 2, 3> int_seq)
{
int _tuple;
return getc((get<0>(_tuple)), (get<1>(_tuple)), (get<2>(_tuple)), (get<3>(_tuple)));
}这个和我们之前看到的规则有些不同 什么一元二元 没用到哇
你说括号好多？不和我们平时调用的一样
return getc(get<ints>(_tuple)...);
template<>
void call<int, 0, 1, 2, 3>(integer_sequence<int, 0, 1, 2, 3> int_seq)
{
int _tuple;
return getc(get<0>(_tuple), get<1>(_tuple), get<2>(_tuple), get<3>(_tuple));
}如此更改 括号没了
这个可以说就是 把 ... 左边的 成一个整体 get<ints>(_tuple)
有前提 必须得是在 类似于函数参数中
return (get<ints>(_tuple)...);
这样写很遗憾是错误的
我们只能使用
一元二元的规则
return (get<ints>(_tuple),...);
template<>
int call<int, 0, 1, 2, 3>(integer_sequence<int, 0, 1, 2, 3> int_seq)
{
int _tuple;
return get<0>(_tuple) , (get<1>(_tuple) , (get<2>(_tuple) , get<3>(_tuple)));
}
如果这样
return ((get<ints>(_tuple),...));
template<>
int call<int, 0, 1, 2, 3>(integer_sequence<int, 0, 1, 2, 3> int_seq)
{
int _tuple;
return (get<0>(_tuple) , (get<1>(_tuple) , (get<2>(_tuple) , get<3>(_tuple))));
}
外部就会多个括号-------------------------------------------------------------------------------------------------------------
jk<int> b;
b.h = 10;
call(&b,&b,&b,&b);
//调用处
template<typename ...T>
auto call(T* ... c)//integer_sequence<T*, ints...> int_seq)
{
return (c -> h,...);
//return (*_fun)(c -> h...);
// return (*_fun)( [&](){return c->h; }()...);
// return (c&&...&&0);
}
我们还可以访问类的成员
template<>
int call<jk<int>, jk<int>, jk<int>, jk<int> >(jk<int> * __c0, jk<int> * __c1, jk<int> * __c2, jk<int> * __c3)
{
return __c0->h , (__c1->h , (__c2->h , __c3->h));
}使用函数指针
template<typename Ret,typename ...T>
using b = Ret(*)(T...);
b<void,int,int,int,int> _fun;
return (*_fun)(c -> h...);
template<>
void call<jk<int>, jk<int>, jk<int>, jk<int> >(jk<int> * __c0, jk<int> * __c1, jk<int> * __c2, jk<int> * __c3)
{
return (*_fun)(__c0->h, __c1->h, __c2->h, __c3->h);
}lambda函数
return (*_fun)( [&](){return c->h; }()...);template<>
void call<jk<int>, jk<int>, jk<int>, jk<int> >(jk<int> * __c0, jk<int> * __c1, jk<int> * __c2, jk<int> * __c3)
{
class __lambda_41_21
{
public:
inline /*constexpr */ int operator()() const
{
return __c0->h;
}
private:
jk<int> & * __c0;
public:
__lambda_41_21(jk<int> & * ___c0)
: __c0{___c0}
{}
} __lambda_41_21{__c0};
class __lambda_41_21
{
public:
inline /*constexpr */ int operator()() const
{
return __c1->h;
}
private:
jk<int> & * __c1;
public:
__lambda_41_21(jk<int> & * ___c1)
: __c1{___c1}
{}
} __lambda_41_21{__c1};
class __lambda_41_21
{
public:
inline /*constexpr */ int operator()() const
{
return __c2->h;
}
private:
jk<int> & * __c2;
public:
__lambda_41_21(jk<int> & * ___c2)
: __c2{___c2}
{}
} __lambda_41_21{__c2};
class __lambda_41_21
{
public:
inline /*constexpr */ int operator()() const
{
return __c3->h;
}
private:
jk<int> & * __c3;
public:
__lambda_41_21(jk<int> & * ___c3)
: __c3{___c3}
{}
} __lambda_41_21{__c3};
return (*_fun)(__lambda_41_21.operator()(), __lambda_41_21.operator()(), __lambda_41_21.operator()(), __lambda_41_21.operator()());
大概就是这样
return (*_fun)( [&](){return c->h; }()，[&](){return c->h; }()，[&](){return c->h; }()，[&](){return c->h; }());从这里我们也可以看出 lambda 本质是是一个类里面
使用了 operator()
我现所知晓的折叠表达式已经说完了