将右值元组转换为左值元组

Question

如果我把整个概念弄错了，我很抱歉，但我正在尝试将一个元组作为实际对象的容器，只有在销毁这些对象时，这些对象才会超出范围。

我目前有这个：

class MiniThread {
public:
    ~MiniThread() {
        if (m_thread) {
            if (m_thread->joinable())
                m_thread->join();

            delete m_thread;
        }
    }

    void join()
    {
        if (m_thread == nullptr)
            return;

        m_thread->join();
        m_thread = nullptr;
    }

    template<typename F, typename... Args>
    void run(F func, Args... args)
    {
        if (m_thread != nullptr)
            join();

        auto tuple = std::forward_as_tuple(args...);

        m_thread = new std::thread([=]() {
            __try
            {
                std::apply(func, tuple);
            }
            __except (CrashDump::GenerateDump(GetExceptionInformation()))
            {
                // TODO: log.
                exit(1);
            }
        });

        m_started = true;
    }

    bool started() const { return m_started; }

private:
    std::thread *m_thread = nullptr;
    bool m_started = false;
};


std::string getString()
{
    return std::string("sono");
}

int main()
{
    auto test = [&](std::string seila, const std::string& po, std::promise<int>* p)
    {
        std::cout << seila.c_str() << std::endl;
        std::cout << po.c_str() << std::endl;
        p->set_value(10);
    };

    std::promise<int> p;
    std::future<int> f;

    MiniThread thread;
    std::string hello = "hello";
    std::string seilapo = "seilapo";

    f = p.get_future();
    thread.run(test, getString(), "how are you", &p);

    thread.join();
    int ftest = f.get();
    std::cout << ftest << std::endl;
}

当线程运行时，args 不再可靠。他们已经被摧毁了。所以我想知道是否有办法在线程调用中复制它们按值。我已经尝试将可变参数移动到元组中，但是元组总是使用rvalues 呈现并且同样失败。

Answer 1

这个：

auto tuple = std::forward_as_tuple(args...);

在args... 中创建一个引用元组这就是forward_as_tuple 的工作。然后，您将按值捕获该引用元组：

m_thread = new std::thread([=]{ /* ... */ });

因此，一旦您的论点超出范围，您就只能保留对它们的引用……这将悬而未决。

但实际上你根本不需要有一个元组。只需复制参数本身：

m_thread = std::thread([=]() {
    func(args...); // func and args, no tuple here
});

同样不要写new thread - thread 已经是句柄类型，只需创建一个。

---

上述复制参数。如果您想移动它们，那么在 C++17 中，是的，您需要有一个 tuple 并使用 std::apply。但不是forward_as_tuple...只是make_tuple：

m_thread = std::thread([func, args=std::make_tuple(std::move(args)...)]() mutable {
    std::apply(func, std::move(args));
});

在 C++20 中，您将不再需要 tuple，并且可以编写一个包扩展：

m_thread = std::thread([func, ...args=std::move(args)]() mutable {
    func(std::move(args)...);
});