How does std::thread store variadic arguments passed through its constructor?

Question

Let's say I declare a thread with the following code:

#include <thread>
#include <iostream>

void printStuff(const char* c, long x) {
   std::cout << x << " bottles of " << c << " on the wall\n";
}

int main()
{
   std::thread t(printStuff, "beer", 900000000);

   t.join();
}

How are the arguments printStuff, "beer," and 900000000 stored in the thread?

I know they are using a variadic template, where you first pass in a function and then a parameter pack of arguments. I am confused on how they forward all these template arguments, and then somehow call the inputted function with all the arguments when join or detach is called.

std::function has similar functionality where when you call std::bind it will store a function and its arguments inside the object, and then when you call the std::function object it will just execute the bound function with its arguments.

I am basically trying to implement my own version of std::function, for my own edification. I am curious how in C++ you would go about storing a function with a bunch of arbitrary parameters inside an object, and then having a method that would call the function with the passed in arguments.

I have looked at both the thread and std::function class, and both seem to be using tuples in some way to store their arguments. In a declaration of a tuple you have to specify what types you are storing in it:

std::tuple<int, std::string> tup;

How do std::function and thread get around this by storing their variadic arguments in tuples? Furthermore, how do they retrieve the function and call it with all of the arguments?

They are doing exactly what you described: using a tuple. That's it. — Sam Varshavchik, Jun 21 '22 at 23:19
@TedLyngmo thank you for the answer. That works for what I am trying to do, and I'll probably end up doing that instead. I'm still curious though on how to store variadic arguments in this way — TwistedBlizzard, Jun 21 '22 at 23:22
@beangod Good. I'll take a look at it in a few days when I have access to a computer. — Ted Lyngmo, Jun 25 '22 at 07:13
@beangod Ok, I added a new answer with a possible solution to how I've interpreted the goal. — Ted Lyngmo, Jun 28 '22 at 08:35

Ted Lyngmo · Accepted Answer · 2022-06-28T10:36:10.153

I am basically trying to implement my own version of std::function, for my own edification. I am curious how in C++ you would go about storing a function with a bunch of arbitrary parameters inside an object, and then having a method that would call the function with the passed in arguments.

std::function is a beast of a class so I won't pretend that this is anywhere close to as complete. std::function uses type erasure and small object optimization but I'll use polymorphism and store a base class pointer to a semi-anonymous implementation of a function wrapper to show how it can be done. I say semi-anonymous because it actually has a name, but it's defined locally inside the function that instantiates it. Storing the pointer (or the empty state) will be done in a std::unique_ptr<funcbase>.

The goal, as I've understood it, is to create a class with this basic interface:

template <class R, class... Args>
class fn_with_args<R(Args...)> {
public:
    template <class F> fn_with_args(F&& f, Args&&... args);
    R operator()();
};

That is, we need instances of fn_with_args<R(Args...)> to be able to store function pointers / functors that when invoked with the stored arguments returns R.

#include <functional>
#include <memory>
#include <tuple>

template <class> class fn_with_args; // not implemented

template <class R, class... Args>
class fn_with_args<R(Args...)> {
    // an abstract base for cloneable function objects with an operator()() to call
    struct funcbase {
        virtual ~funcbase() = default;
        virtual std::unique_ptr<funcbase> clone() const = 0;
        virtual R operator()() = 0;
    };

public:
    // create empty "fn_with_args":
    fn_with_args() noexcept = default;
    fn_with_args(std::nullptr_t) noexcept {};

    // copy ctor - if store contains a pointer to a funcbase,
    //             let it clone itself
    fn_with_args(const fn_with_args& other) :
        store(other.store ? other.store->clone() : nullptr) {}

    // copy assignment
    fn_with_args& operator=(const fn_with_args& other) {
        if(this != &other) *this = fn_with_args(other); // copy+move
        return *this;
    }

    // moving can be done by default:
    fn_with_args(fn_with_args&& other) noexcept = default;
    fn_with_args& operator=(fn_with_args&& other) noexcept = default;

    // constructing and storing arguments
    template <class F>
    fn_with_args(F&& f, Args&&... args) {
        // the semi-anonymous implementation that inherits from funcbase
        // and stores both the function and the arguments:
        struct funcimpl : funcbase {
            funcimpl(F&& f, Args&&... a)
                : func{std::forward<F>(f)}, args{std::forward<Args>(a)...} {}
            
            // cloning via a base class pointer:
            std::unique_ptr<funcbase> clone() const override {
                return std::make_unique<funcimpl>(*this);
            }

            // the operator that will call `func` with the stored arguments:
            R operator()() override { return std::apply(func, args); }

            F func;                   // the actual function/functor
            std::tuple<Args...> args; // and the stored arguments
        };

        // create and store an instance of the above semi-anonymous class:
        store = std::make_unique<funcimpl>(std::forward<F>(f),
                                           std::forward<Args>(args)...);
    }

    // The call interface. It'll dereference `store` and then call it which
    // will call the overridden operator()() in the semi-anonymous `funcimpl`:
    R operator()() { 
        if(store) return (*store)();
        throw std::bad_function_call();
    }

private:
    std::unique_ptr<funcbase> store;
};

Example usage:

#include <iostream>

double foo(int x) {
    return x * 3.14159;
}

int main() {
    fn_with_args<int(double)> f1([](double d) -> int { return d; }, 3.14159);
    std::cout << f1() << '\n';

    fn_with_args<void()> f2;  // create empty
    //f2(); // would throw "bad_function_call" since it is "empty"

    // populate it
    f2 = fn_with_args<void()>([]{ std::cout << "void\n"; });
    f2();

    // call regular function:
    fn_with_args<double(int)> f3(foo, 2);
    std::cout << f3() << '\n';

    // example with capture:
    int v = 123;
    f1 = fn_with_args<int(double)>([v](double d) -> int { return v * d; }, 3.14159);
    std::cout << f1() << '\n';

    // copying:
    auto f11 = f1;
    std::cout << f11() << '\n'; // calling the copy
}

Demo

Thank you so much for the code explanations. I must admit that I don't really understand all of it, but this has given me a lot to think about. Also, I really appreciate the many comments that you wrote, as that as that really made it much easier to understand, unlike the actual std::function class. — TwistedBlizzard, Jul 01 '22 at 20:02
@beangod Glad it helped! If there's anything you'd like me to explain in more detail, I'll gladly update the answer. — Ted Lyngmo, Jul 01 '22 at 22:21
I'm still curious on how we could "bind" our arguments to our class or pass them in through the constructor instead of specifying them in the '<' signs. For instance, you don't declare a thread like std::thread t, you would write std::thread t(method, arg). This is very convenient as this way we can store multiple threads with different methods and arguments in single data structures like vectors. — TwistedBlizzard, Jul 02 '22 at 02:16
@beangod `std::function` doesn't store arguments like the `fn_with_args` class above. I don't think `std::thread` does either . It takes the arguments it gets to the constructor and passes those on to the thread it starts. I see no reason for it to store them anywhere. Both have templated constructors and `std::function` has [deduction guides](https://en.cppreference.com/w/cpp/utility/functional/function/deduction_guides). so that you can do `std::function foo = []{ return 3.1; };` and it'll create a `std::function` etc. — Ted Lyngmo, Jul 02 '22 at 06:08

ShaulF · Answer 2 · 2022-06-21T23:46:21.120

1

you should store the params in std::tuple and invoke them using std::apply

#include <functional>
#include <tuple>
#include <vector>

template <class R>
class Function_Wrapper {
 public:
  template <typename Callable, typename... Args>
  Function_Wrapper(Callable&& callable, Args&&... args)
      : fn_([=, args = std::make_tuple(std::forward<Args>(args)...)]() {
          return std::apply(callable, args);
        }) {}

  decltype(auto) run() {
    // call our callable with the passed in arguments
    return fn_();
  }

  decltype(auto) operator()() { return run(); }

 private:
  std::function<R()> fn_;
};

int add(int a, int b) { return a + b; }

int main() {
  std::vector<Function_Wrapper<int>> f{{&add, 9, 30}, {&add, 1, 2}};
  return f[0].run() + f[1]();
}

Here in Compiler Explorer

edited Jun 21 '22 at 23:46

answered Jun 21 '22 at 22:58

ShaulF

841
10
17

I'm getting an error from this code that says "callable_: a member of a class template cannot acquire a function type." – TwistedBlizzard Jun 21 '22 at 23:23
I fixed the code, to match @TedLyngmo observation. Please see the Compiler Explorer link – ShaulF Jun 21 '22 at 23:30
I made a shorter version – ShaulF Jun 21 '22 at 23:47

How does std::thread store variadic arguments passed through its constructor?

2 Answers2