你也可以写绑定.

#include "果型.cpp"
元<型名 T>构 是无引针:是指针<移引用型<T>>{};
元<型名 T>构 是无引成函:是成函针<移引用型<T>>{};
//要仔细理解这两个模板的意思

元<型名 R,型名 F,型名 W,型名...P>内联
允许如型<是无引成函<F>::值&&是无引针<W>::值,R>
调用(F&&f,W&&本针,P&&...o){
    中(本针->*f)(前向<P>(o)...);
}
元<型名 R,型名 F,型名 W,型名...P>内联
允许如型<是无引成函<F>::值&&!是无引针<W>::值,R>
调用(F&&f,W&&p,P&&...o){
    中(p.*f)(前向<P>(o)...);
}//p为引用
//上两个用于成员函数
元<型名 R,型名 F,型名...P>内联
允许如型<是无引针<F>::值,R>调用(F&&f,P&&...o){
    中(*f)(前向<P>(o)...);
}//可以为引用,可以为指针
元<型名 R,型名 F,型名...P>内联
允许如型<!是无引针<F>::值&&!是无引成函<F>::值,R>
调用(F&&f,P&&...o){
    中 f(前向<P>(o)...);
}
//上两个用于无成员函数
//果型,即结果类型
元<型名 F,型名...T>构 绑呀{//关键:绑定了一个元组
    //用 G=退化型<F>;用 A=元组<T...>;
    用 G=退化型<F>;用 A=元组<退化型<T>...>;
    用 R=果型<G>;G g;A a;
公:
    元<类 F,类...B>绑呀(F&f,B&...o):g(f),a(o...){}
    元<型名 F,型名...B>
    绑呀(F&&f,B&&...o):g(移动(f)),a(移动(o)...){}
    元<型名...C>R 符号()(C&&...o){
        常式 整 N=型长...(T)+型长...(C);
        型名 造序<N>::型 p;
        中 呀(p,连接元组(a,按元组前向(前向<C>(o)...)));
    }//这里关键.(T+C)构成完整的参数个数
    元<整...I,型名 T>动 呀(序列<I...>,T&t){
        中 调用<R>(g,取<I>(前向<T>(t))...);
    }
};

元<型名 F,型名...P>内联 动 绑定(F&&f,P&&...o){
    中 绑呀<F,P...>(f,前向<P>(o)...);
}//还要研究(退化型...),教训是老是编译不过,
//把一堆复杂的先去掉,用一个最简单的,再逐渐增加.
元<型名 F,型名...P>内联 
动 绑定(F&f,P&...o){中 绑呀<F,P...>(f,o...);}

测试:

#include "绑定.cpp"
整 取呀(){
    中 5;
}
整 取数(整 i,整 j,整 k,整 m){
    中 i+j+k+m;
}
空 呀(){//以成员函数最重要
    动 t=绑定(&取数,3,4,3);
    打印(t(7));
}
构 测试{
    向量<串>们{"啊","中国菜","呀","哈"};
    整 取呀(){
        中 们.大小();
    }
    整 取数(整 i){
        中 取呀()+i;
    }
    空 呀(){//以成员函数最重要
        动 t=绑定(&测试::取数,本);
        打印(t(7));
    }
};

空 主(){
    呀();测试 a;a.呀();
}