C++ 如何将函数绑定到一个类中？

我试图理解函数绑定器是如何工作的。到目前为止，我已经有了一个0-2参数的小活页夹，它工作得很好，但我不知道如何将它放入一个类（例如函数）中，以将其存储在一个集合中

template <int>
struct placeholder {};

static const placeholder<1> _1_;
static const placeholder<2> _2_;

template <typename t>
struct list1
{
    list1(const t& i) : itm(i) {}
    t operator[](const placeholder<1>&) const {return itm;}
    template <typename it>
    it operator[](const it& _it) const {return _it;}

    template <typename fn>
    void operator()(fn func)
    {
        func(itm);
    }
    template <typename func, typename lst>
    void operator()(func fn, const lst& _lst)
    {
        fn(_lst[itm]);
    }
private:
    t itm;
};

template <typename t, typename t1>
struct list2
{
    list2(const t& i, const t1& i1) : itm(i), itm1(i1) {}
    t operator[](const placeholder<1>&) const {return itm;}
    t1 operator[](const placeholder<2>&) const {return itm1;}
    template <typename it>
    it operator[](const it& _it) const {return _it;}

    template <typename fn>
    void operator()(fn func)
    {
        func(itm, itm1);
    }
    template <typename func, typename lst>
    void operator()(func fn, const lst& _lst)
    {
        fn(_lst[itm], _lst[itm1]);
    }
private:
    t itm;
    t1 itm1;
};

template <typename func, typename lst>
class binder
{
public:
    binder(func _fn, const lst& _lst) : fn(_fn), _list(_lst) {}
    void operator()()
    {
        _list(fn);
    }
    template <typename a0>
    void operator()(const a0& _a0)
    {
        list1<a0> lst(_a0);
        _list(fn, lst);
    }
    template <typename a0, typename a1>
    void operator()(const a0& _a0, const a1& _a1)
    {
        list2<a0, a1> lst(_a0, _a1);
        _list(fn, lst);
    }
private:
    func fn;
    lst _list;
};

模板
结构占位符{}；
静态常量占位符1；
静态常量占位符2；
模板
结构列表1
{
清单1（常数t&i）：itm（i）{}
t运算符[]（常量占位符&）常量{return itm；}
模板
it运算符[]（const it&_it）const{return_it；}
模板
void运算符（）（fn func）
{
func（itm）；
}
模板
void运算符（）（函数fn，常量lst和_lst）
{
fn（_lst[itm]）；
}
私人：
itm；
};
模板
结构列表2
{
清单2（常数t&i，常数t1&i1）：itm（i），itm1（i1）{
t运算符[]（常量占位符&）常量{return itm；}
t1运算符[]（常量占位符&）常量{return itm1；}
模板
it运算符[]（const it&_it）const{return_it；}
模板
void运算符（）（fn func）
{
func（itm，itm1）；
}
模板
void运算符（）（函数fn，常量lst和_lst）
{
fn（_lst[itm]，_lst[itm1]）；
}
私人：
itm；
t1-itm1；
};
模板
活页夹
{
公众：
活页夹（func _fn，const lst&_lst）：fn（_fn），_list（_lst）{
void运算符（）（）
{
_名单（fn）；
}
模板
void运算符（）（常量a0和_a0）
{
列表1 lst（_a0）；
_名单（fn、lst）；
}
模板
void运算符（）（常数a0和a0，常数a1和a1）
{
列表2 lst（_a0，_a1）；
_名单（fn、lst）；
}
私人：
func-fn；
lst_列表；
};

---

通常我会使用类型擦除，但我就是搞不懂。我需要从基类继承并使操作符（）（…）-template成为虚拟的，这是不可能的。有人知道他们是如何在标准库中解决这个问题的吗？

我不太明白你想在这里实现什么，但我相信我能帮你我想把活页夹放到一个普通的课堂上。就像标准库那样（函数f=std:：bind（…）