将所有可变参数模板参数解压缩,除了最后一个作为变量类型

Question

我有一个模板类,它接受可变数量的类型作为参数.构造函数接受指向使用Args... - 1作为参数类型的类的实例的指针.通过互联网搜索我发现a 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;
};

Answer 1

#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);
}

DEMO

编辑之前上一个问题的答案:

#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将被视为可能抛出代码.