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

我有一个模板类，它接受数量可变的类型作为参数。构造函数接受指向使用

Args…-1

作为参数类型。通过互联网搜索，我发现通常使用

std:：tuple

来处理这类问题，但我不明白如何获取模板参数，创建一个tuple，删除最后一个类型，然后再次解包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_;
};

模板
类MyClass
{
公众：
MyClass（MyClass*父对象）：父对象（父对象）//应该是Args-1
{
}
MyClass*父类（）
{
返回父对象；
}
私人：
MyClass*父类；
};

我在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;
};

模板
结构concat_元组{}；
模板
结构concat_元组
{
使用type=std:：tuple；
};
模板
结构删除_last；
模板
结构删除最后一个
{
使用type=std:：tuple；
};
模板
结构删除最后一个
{
使用type=typename concat\u tuple:：type；
};

---

如果没有

noexcept

说明符，上述断言将失败，因为对

pop_back

的调用将被视为可能抛出代码。

您的代码一切正常（只要您保持Args未注释），也许您没有将creator方法公开。。。请记住，默认的类成员访问修改器是私有的…@WojciechFrohmberg OP不知道如何从

remove_last:：type

@WojciechFrohmberg Commented Args只是一个输入错误：谢谢你的回答，它可以工作。然而，在与我自己的代码进行了一些斗争之后，我不得不编辑这个问题，以反映最近对我的代码所做的更改。如您所见，我不再需要创建该类的新实例，但它必须作为构造函数参数传递，并作为成员变量存储。它工作得非常好，谢谢。你能解释一下代码的作用和另外两个问题吗：为什么pop_back函数没有主体，为什么使用noexcept？

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

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;

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

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