我试图创建一个对象，它存储从static函数创建的对象的元组，但是当创建tuple时，对象被复制到tuple中，而不是直接放置到tuple中，调用tuple中每个对象的析构函数两次，我想避免这种行为。有没有一种方法可以解决这个问题，而不必为每个插件类创建自定义的移动/复制构造函数？
代码如下所示：

#include <tuple>
#include <iostream>

namespace details
{
    template<typename PluginT, typename ContainerT, typename TupleT, size_t... Is>
    static PluginT construct_plugin(ContainerT& container, TupleT&& tuple, std::index_sequence<Is...>) 
    {
        return PluginT(container, std::get<Is>(std::forward<TupleT>(tuple))...);
    }

    template<typename PluginT, typename ContainerT, typename TupleT>
    static PluginT construct_plugin(ContainerT& container, TupleT&& tuple) 
    {
        return construct_plugin<PluginT>(container, std::forward<TupleT>(tuple), std::make_index_sequence<std::tuple_size<std::decay_t<TupleT>>::value>{});
    }
}

struct simple_plugin
{
    template<typename ContainerT>
    simple_plugin(ContainerT& container) {}

    ~simple_plugin()
    {
        std::cout << "simple_plugin destructor" << std::endl;
    }
};

struct plugin_with_params
{
    template<typename ContainerT>
    plugin_with_params(ContainerT& container, int argc, char* argv[]) {}

    ~plugin_with_params()
    {
        std::cout << "plugin_with_params destructor" << std::endl;
    }
};

template<typename... PluginTs>
struct plugin_container
{
    std::tuple<PluginTs...> plugins;

    template<typename... TupleTs>
    plugin_container(TupleTs&&... tuples) :
        plugins(details::construct_plugin<PluginTs>(*this, std::forward<TupleTs>(tuples))...) {}
};

int main(int argc, char* argv[])
{
    plugin_container<simple_plugin, plugin_with_params> container(std::make_tuple(), std::make_tuple(argc, argv));
    return 0;
}

以下是实际的行为：https://godbolt.org/z/bqjv5r88x