Question

我有一个简单的类A，提供一个可变参数函数模板。此函数使用A内的私有数据，但函数本身是公共的。课程如下：

class A {
public:

    A() :
    _bla("bla: ") {
    }

    template <class T>
    void bar(const T& value) {
        std::cout << _bla << value << std::endl;
    }

    template <class H, class... T>
    void bar(const H& value, const T&... data) {
        std::cout << _bla << value << std::endl;
        bar(data...);
    }

private:
    const std::string _bla;
};

在一个名为 foo.hpp 的单独文件中，我有一个函数foo()，它应该能够接收并使用函数a.bar()作为参数：< / p>

int main(int argc, char *argv[]) {    
    A a;
    a.bar(1, "two", 3, 4);
    foo(&a.bar);
}

我不太确定从哪里开始，但我尝试了以下 - 这不起作用。我该怎么做才能正确：

template <typename... T>
inline void foo(void (bar *)(const T&...)) {
    unsigned int x(0), y(0), z(0);
    bar(x, y, z);
}

加分问题：还有一种方法不仅可以打电话：

foo(&a.bar);

但也请foo与a.bar绑定一些参数，例如：

foo(&(a.bar(p1, p2));

我可以简单地将p1和p2添加到foo定义本身，例如：

foo(p1, p2, &a.bar);

但如果我之前可以添加这些参数，那么对于我的目的来说，语义会更好。

Answer 1

您无法在不实例化的情况下传递函数模板的地址，因为它被视为整个重载集（无论模板是否为可变参数）。但是，您可以将其包装在通用仿函数中：

struct bar_caller
{
    template<typename... Ts>
    void operator () (A& a, Ts&&... args)
    {
        a.bar(std::forward<Ts>(args)...);
    }
};

然后让你的函数foo()定义如下：

template<typename F>
inline void foo(A& a, F f) {
    unsigned int x(0), y(0), z(0);
    f(a, x, y, z);
}

因此，main()中的函数调用将变为：

int main()
{
    A a;
    a.bar(1, "two", 3, 4);
    foo(a, bar_caller());
}

不幸的是，目前在C ++中没有办法在没有定义单独的类的情况下轻松地在函子中包装重载集 - 如上面对bar_caller所做的那样。

修改

如果您不想将A对象直接传递给foo()，您仍然可以让bar_caller封装对该函数所在的A对象的引用必须调用bar()（只需要处理对象的生命周期，这样你就不会悬挂这个引用）：

struct bar_caller { bar_caller(A& a_) : a(a_) { } template<typename... Ts> void operator () (Ts&&... args) { a.bar(std::forward<Ts>(args)...); } A& a; };

然后您可以按如下方式重写foo()和main()：

template<typename F> inline void foo(F f) { unsigned int x(0), y(0), z(0); f(x, y, z); } int main() { A a; a.bar(1, "two", 3, 4); foo(bar_caller(a)); }

指向可变参数函数模板的指针

1 个答案: