将除最后一个作为变量类型的变量外的所有可变模板参数解包

Unpack all variadic template arguments except last one as type of variable

本文关键字：变量 参数 最后一个 类型      更新时间：2023-10-16

我有一个模板类，它接受数量可变的类型作为参数。构造函数接受指向使用Args... - 1作为参数类型的类实例的指针。在互联网上搜索时，我发现std::tuple通常用于处理这类问题，但我不明白如何获取模板参数，创建一个元组，删除最后一个类型，然后再次解压缩元组，并将结果存储在parent()函数稍后可以检索的变量中。

template<typename ...Args>
class MyClass
{
public:
    MyClass(MyClass<Args...> *parent) : parent_(parent) // Should be Args - 1
   {
   }
    MyClass<Args...>* parent()
    {
        return parent_;
    }
private:
    MyClass<Args...> *parent_;
};

我在StackOverflow上找到了关于涉及元组的类似主题的不同答案。这段代码已经发布在另一个问题上，应该得到一个包含除最后一个参数外的所有参数的元组。问题是，我不知道如何调整它以再次打开元组。

template<typename, typename>
struct concat_tuple { };
template<typename... Ts, typename... Us>
struct concat_tuple<std::tuple<Ts...>, std::tuple<Us...>>
{
    using type = std::tuple<Ts..., Us...>;
};
template <class T>
struct remove_last;
template <class T>
struct remove_last<std::tuple<T>>
{
    using type = std::tuple<>;
};
template <class T, class... Args>
struct remove_last<std::tuple<T, Args...>>
{
    using type = typename concat_tuple<std::tuple<T>, typename remove_last<std::tuple<Args...>>::type>::type;
};

#include <type_traits>
#include <tuple>
#include <utility>
#include <cstddef>
template <template <typename...> class C, typename... Args, std::size_t... Is>
auto pop_back(std::index_sequence<Is...>) noexcept
    -> C<std::tuple_element_t<Is, std::tuple<Args...>>...>&&;
template <typename... Args>
class MyClass
{
    using Parent = std::remove_reference_t<
                      decltype(pop_back<::MyClass, Args...>(std::make_index_sequence<sizeof...(Args) - 1>{}))
                   >;
public:    
    explicit MyClass(Parent* parent) : parent_(parent)
    {
    }
    Parent* parent()
    {
        return parent_;
    }
private:
    Parent* parent_;
};
template <>
class MyClass<> {};
int main()
{
    MyClass<> a;
    MyClass<int> b(&a);    
    MyClass<int, char> c(&b);
    MyClass<int, char, float> d(&c);
}

演示

编辑前上一个问题的答案：

#include <tuple>
#include <utility>
#include <cstddef>
template <typename... Args>
class MyClass
{
public:    
    auto newInstance()
    {
        return newInstance(std::make_index_sequence<sizeof...(Args) - 1>{});
    }
private:        
    template <std::size_t... Is>
    MyClass<typename std::tuple_element<Is, std::tuple<Args...>>::type...> newInstance(std::index_sequence<Is...>)
    {
        return {};
    }
};

演示2

为什么pop_back函数没有正文

这实际上是通过函数声明实现的特性。或者，您可以使用更经典的结构专门化解决方案：

template <typename T, typename S>
struct pop_back;
template <template <typename...> class C, typename... Args, std::size_t... Is>
struct pop_back<C<Args...>, std::index_sequence<Is...>>
{
    using type = C<std::tuple_element_t<Is, std::tuple<Args...>>...>;
};

然后使用：

using Parent = typename pop_back<MyClass, std::make_index_sequence<sizeof...(Args) - 1>>::type;

也就是说，我使用了一个函数声明来缩短语法。它不需要主体，因为没有人应该在评估的上下文中调用这个函数。

为什么使用noexcept

想象一下你有一个功能：

void foo(MyClass<int, char>) noexcept {}

在其他地方，您需要检查呼叫是否为noexcept:

static_assert(noexcept(foo(pop_back<MyClass, int, char, float>(std::index_sequence<0, 1>{}))), "!");

如果没有noexcept说明符，上述断言将失败，因为对pop_back的调用可能被认为是抛出代码。

相关文章：