Pointer to variadic function template

Question

I have a simple class A, providing a variadic function template. This function uses private data from within A, but the function itself is public. The class goes as follows:

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;
};

In a separate file, named foo.hpp, I have a function foo(), that should be able to receive and use the function a.bar() as an argument:

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

I'm not very sure of where to start, but I've tried the following -- which does not work. How can I do it correctly:

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

Bonus question: is there a way to call not only:

foo(&a.bar);

but also call foo with a.bar bound to some parameters, like:

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

I can simply add p1 and p2 to foo definition itself, like in:

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

but it would be semantically better to my purpose if I could add these parameters before.

Why the enable_if mess? You can just overload it as void bar() {}. — jrok
– jrok, Commented May 6, 2013 at 15:33
By the way, there's no need to use enable_if to tell whether the argument pack is empty. Just have one template overload for (H,T...) and one overload with no arguments that does nothing. — Mike Seymour
– Mike Seymour, Commented May 6, 2013 at 15:34
foo accepts a function, but a.bar is not a function. It is a template. Templates have no addresses. There are functions a.bar<int>, a.bar<double, char> etc; which one do you want to pass to foo? Also, how do you distinguish a.bar(p1, p2) as a function bound to some parameters and a.bar(p1, p2) as a function fully applied to all parameters? — n. m. could be an AI
– n. m. could be an AI, Commented May 6, 2013 at 15:38

Andy Prowl · Accepted Answer · 2013-05-06 15:55:58Z

9

You cannot pass the address of a function template without instantiating it, because that is treated as a whole overload set (no matter whether the template is variadic or not). You can, however, wrap it in a generic functor:

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

And then let your function foo() be defined as follows:

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

So your function call in main() would become:

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

Unfortunately, at the moment there is no way in C++ to easily wrap an overload set in a functor without defining a separate class - as done above for bar_caller.

EDIT:

If you do not want to pass an A object directly to foo(), you can still let your bar_caller encapsulate a reference to the A object on which the function bar() has to be called (just take care of object lifetime, so that you won't be making that reference dangling):

struct bar_caller
{
    bar_caller(A& a_) : a(a_) { }

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

    A& a;
};

You could then rewrite foo() and main() as follows:

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));
}

edited May 6, 2013 at 15:55

answered May 6, 2013 at 15:30

Andy Prowl

127k25 gold badges394 silver badges455 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Rubens Over a year ago

+1 Andy, thanks very much for your answer! In the real case, I have a class that extends other classes, and includes A, a smaller class in my program. If I get to # include my outer class in A -- which is actually included in the outer class --, I guess the mess I already have would become an epic spaghetti ^^ I don't really mind the extra parameters, I can add them to foo definition, but I really wouldn't like to have to pass A -- my outer class -- to foo. Is there any possible work around?

Rubens Over a year ago

Andy, I actually have A as the outer function, and bar is a function available from inheritance. I was, until now, passing variables as references to foo, so that foo would fill up the variables, and I would call bar in A itself, with the values I've retrieved from foo. I'm just adding a bit of context to make it clearer. I'm checking your edit right now.

Rubens Over a year ago

Perfect solution! I guess I'll be able to do exactly what I want now! Just one last question, what exactly is the meaning of the double reference in void operator()(Ts&&... args){}?

Collectives™ on Stack Overflow

Pointer to variadic function template

1 Answer 1

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related