c++的绑定实现.

元<型名...>构 空器{用 型=空;};
元<型名...A>用 是空型=型名 空器<A...>::型;

元<型名 T,型名=空>构 是灵针:假型{};
元<型名 T>构 是灵针<T,是空型<推导(求值<T>().符号->()),推导(求值<T>().取())>>:真型{};//推导失败没啥
//有这两个操作的就是灵针.
//只要返回入,则可以导入元<型名 F>中
枚 针型{是引,是针,是灵};

元<型名 F>常式 整 求针型(){
    如(是指针值<F>)中 是针;
    异 如(是灵针<F>::值)中 是灵;//要加个值
    异 中 是引;
}//要加常式,
元<整 N,型名 P,型名 F>动 绑定实现(P&&p,F&&f){
    如 常式(N==1)
        中[&](动&&...o){中(p->*f)(o...);};
    异 如 常式(N==2)
        中[&](动&&...o){中(p.取()->*f)(o...);};
    异 中[&](动&&...o){中(p.*f)(o...);};
}//要这样使用,这样分发,我叉,编译时计算的N,一定要加常式,这是关键

元<型名 P,型名 F>动 绑定(P&&p,F&&f){
    常式 整 N=求针型<F>();
    中 绑定实现<N>(前向<P>(p),前向<F>(f));
}//在这里,直接F.

代码如上.关键点是只要是使用编译时的N,无论在哪里都要加上常式.
参考地址.
人家的实现更复杂.我也不喜欢再绑定参数了,麻烦.
要深刻理解下面代码,如何编译时运算?,还是基础不牢:

template<std::size_t I>
auto& get(person& p) {
    if constexpr (I == 0) {
        return p.id;
    }
    else if constexpr (I == 1) {
        return p.name;
    }
    else if constexpr (I == 2) {
        return p.age;
    }
}
template <typename T>
std::string to_string(T t){
    if constexpr(std::is_same_v<T, std::string>)//常式,常式,有编译时就有常式.
        return t;
    else
        return std::to_string(t);
}