Vector of std::function with different signatures

by

You haven’t said what you expect to be able to do with func2 after putting it in a vector with the wrong type.

You can easily use std::bind to put it in the vector if you know the arguments ahead of time:

const std::vector<std::function<void(std::string)>> functions
{
    func1,
    std::bind(func2, std::placeholders::_1, 5, 6)
};

Now functions[1]("foo") will call func2("foo", 5, 6), and will pass 5 and 6 to func2 every time.

Here’s the same thing using a lambda instead of std::bind

const std::vector<std::function<void(std::string)>> functions
{
    func1,
    [=](const std::string& s){ func2(s, func2_arg1, func2_arg2); }
};

If you don’t know the arguments yet, you can bind references to some variables:

int func2_arg1 = 5;
int func2_arg2 = 6;
const std::vector<std::function<void(std::string)>> functions
{
    func1,
    std::bind(func2, std::placeholders::_1, std::ref(func2_arg1), std::ref(func2_arg2))
};

Now functions[1]("foo") will call func2("foo", func2_arg1, func2_arg2), and you can assign new values to the integers to pass different arguments to func2.

And using a lambda function instead of std::bind

const std::vector<std::function<void(std::string)>> functions
{
    func1,
    [&](const std::string& s){ func2(s, func2_arg1, func2_arg2); }
};

This is pretty ugly though, as you need to keep the int variables around for as long as the callable object (the closure or the bind expression) referring to them exists.

More Related Contents:

  1. std::function vs template
  2. Nice way to append a vector to itself
  3. Isn’t the template argument (the signature) of std::function part of its type?
  4. How to directly bind a member function to an std::function in Visual Studio 11?
  5. Comparing std::functions for equality?
  6. std::function fails to distinguish overloaded functions
  7. May std::vector make use of small buffer optimization?
  8. how to avoid static member function when using gsl with c++
  9. std::function and std::bind: what are they, and when should they be used?
  10. Using `std::function` to call non-void function
  11. What is the purpose of std::function and how to use it?
  12. Using ‘void’ template arguments in C++
  13. Is there a standard way of moving a range into a vector?
  14. Optimization code for a debug function (c++11 with templates) [closed]
  15. C++ press enter to continue
  16. Thread pooling in C++11
  17. Is there any use for unique_ptr with array?
  18. Why does ‘std::vector b{2};’ create a 1-element vector, and not a 2-element one?
  19. copy vs std::move for ints
  20. How performing multiple matrix multiplications in CUDA?
  21. How does the custom deleter of std::unique_ptr work?
  22. Variadic Template in VS 2012 (Visual C++ November 2012 CTP)
  23. Operator overload which permits capturing with rvalue but not assigning to
  24. Why is auto_ptr being deprecated?
  25. shared_ptr is to weak_ptr as unique_ptr is to… what?
  26. Why was pair range access removed from C++11?
  27. Why the initializer of std::function has to be CopyConstructible?
  28. Interfacing C++11 array with Cython
  29. const auto std::initializer_list difference between Clang and GCC
  30. Workaround for error C2536: cannot specify explicit initializer for arrays in Visual Studio 2013

Leave a Comment