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?

Answer 1

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

Answer 2

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