我有一个模板类,它接受可变数量的类型作为参数。构造函数接受指向使用 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 {};
}
};
Why the pop_back function has no body?
这实际上是一个根据函数声明实现的特征。或者,您可以使用具有结构特化的更经典的解决方案:
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;
也就是说,我使用了一个函数声明来缩短语法。而且它不需要主体,因为没有人应该在已评估的上下文中调用此函数。
Why are you using 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
的调用将被视为可能抛出代码。
关于c++ - 将除最后一个以外的所有可变参数模板参数解压为变量类型,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/36669081/