让我们假设std::tuple<some_types...>给出了一个.我想创建一个新std::tuple的类型是索引的类型[0, sizeof...(some_types) - 2].例如,让我们假设起始元组是std::tuple<int, double, bool>.我想获得一个定义为的子元组std::tuple<int, double>.
我对可变参数模板很新.作为第一步,我试着写一个struct负责存储不同类型的原始文件std::tuple,目的是创建一个同类的新元组(如std::tuple<decltype(old_tuple)> new_tuple).
template<typename... types>
struct type_list;
template<typename T, typename... types>
struct type_list<T, types...> : public type_list<types...> {
typedef T type;
};
template<typename T>
struct type_list<T> {
typedef T type;
};
我想做的是:
std::tuple<type_list<bool, double, int>::type...> new_tuple // this won't work
下一步是丢弃参数包中的最后一个元素.如何访问type存储的几个type_list？以及如何丢弃其中一些？
谢谢.
假设我有一个变量的类：
class Variable
{
const std::string name;
const double scale;
public:
Variable(const std::string& _name, double _scale) : name(_name), scale(_scale) { }
};
现在我定义一个包含变量的系统类：
template<class... T>
class System
{
std::tuple<T...> variables;
public:
System(???) : ??? { }
};
我如何定义 的构造函数System，它将以某种方式传递其参数来variables初始化它们中的每一个？我希望能够写出这样的东西：
class VAR1 : public Variable { };
class VAR2 : public Variable { };
System<VAR1, VAR2> s{ /* init values: ("VAR1", 10), ("VAR2", 20) */};
这是真的，即结构化绑定在clang（我用最近建造clang version 4.0.0 (trunk 282683)）用一些东西来实现<tuple>，如括号，初始化列表可以使用的东西从<initializer_list>？
我编写了简单的代码只是为了使用一些最新的功能：
struct S { int a; char b; double c; };
auto [a, b, c] = S{1, '2', 3.0};
using A = decltype(a);
using A = int;
using B = decltype(b);
using B = char;
using C = decltype(c);
using C = double;
到目前为止一切顺利，但是当我const之前添加限定符时auto：
struct S { int a; char b; double c; };
const auto [a, b, c] …我想调用std::apply()一个函数；但是，我无法使用，因为std::tuple我使用的当前已包装。例如：
#include <tuple>
template <class T>
struct wrapped
{
wrapped(T t) : t(t) {}
T t;
};
template <class T, class ... Args>
struct delay_call
{
T(*callback)(Args...);
std::tuple<Args...> params;
delay_call(T(*callback)(Args...), Args ... params) :
callback(callback), params(params...)
{}
T call()
{
return std::apply(callback, params);
}
};
template <class T, class ... Args>
struct delay_call_with_wrap
{
T(*callback)(Args...);
std::tuple<wrapped<Args>...> w_params;
delay_call_with_wrap(T(*callback)(Args...), wrapped<Args> ... w_params) :
callback(callback), w_params(w_params...)
{}
T call()
{
std::tuple<Args...> params; // = w_params.t
return std::apply(callback, actual_params); …我想知道是否constexpr std::tuple可以在编译时对a进行排序：
template<typename T>
struct A{ T val; }; // a constexpr-enabled class
constexpr auto t = std::make_tuple( A<int>{3}, A<float>{1.f}, A<double>{2.0});
constexpr auto s = sort(t, [](auto&& v){return v.val; });
static_assert(std::is_same_v<std::tuple<A<float>,
A<double>,
A<int>>,decltype(s)>, "Wups");
这可能吗，这里需要哪些构建块（std::sort是constexpr）？
（据我所知）在运行时不可能做到这一点，因为在运行时无法确定排序元组的类型。如果构建所有排列的类型映射，我也看不到一种方法，实际排列仍然只在运行时才知道。
回答/sf/answers/3220421851/ 给出了一些提示，它应该在编译时工作，但是如何？
我正在编写一个轻量级解析器组合库（类似于 Boost::Spirit）作为业余项目。
有一件事我想要做的，是自动能够转换Result<std::tuple<char>>，Result<std::tuple<char, char>>等成std::string。
同样，如果有例如 aResult<std::tuple<int, int>>我希望能够将其转换为 aResult<std::vector<int>>或更一般地对于包含零个或多个相同类型元素的任何元组，T我希望能够将其自动转换为 a Result<Container<T>>。
一个人如何处理这样的事情？我尝试例如：
template<typename Container>
Result<decltype(std::make_from_tuple<Container>(std::declval<T>()))> () const {
Result{Container{std::make_from_tuple<std::initializer_list<typename std::tuple_element<0, T>::type>> (std::get<T>(*this))}};
}
但这不起作用，因为事实证明不可能像这样以编程方式创建初始化列表。
c++ conversion-operator template-meta-programming stdtuple c++17
给定一个可变参数模板，我想定义一个对象，该对象是可变参数模板中每种类型的向量元组。
就像是：
template <typename... Ts>
class C {
std::tuple<std::vector<T1>, std::vector<T2>,...,std::vector<Tn>> vectors;
};
它不一定是一个数据成员，我的意思是，如果可以使用更多辅助类型或对象来完成此操作，那将不是问题。
std::make_index_sequence我尝试了与的组合std::tuple，但我无法弄清楚。
c++ metaprogramming template-meta-programming variadic-templates stdtuple
以下最小示例使用编译g++ -std=c++11 -Wall tuple.cpp -o tuple：
#include <tuple>
#include <iostream>
template<int i>
char get_elem_i(std::tuple<char, char> t)
{
return std::get<i>(t);
}
int main()
{
std::tuple<char, char> t('H','i');
char c = get_elem_i<0>(t);
std::cout << "The char is: " << c << std::endl;
}
现在，我不想使用指定索引的模板（确切的原因：我拥有自动推断的模板，并且我不想全部指定它们）。所以我的第一次尝试是：
char get_elem_i(int i, std::tuple<char, char> t)
{
return std::get<i>(t);
}
我了解这无法编译。有什么方法可以确保在编译时i就可以知道编译器吗？也许是这样的吗？
char get_elem_i(compile_time_known int i, std::tuple<char, char> t)
我有一段代码,我尝试在给定等待数据类型的情况下自动解码缓冲区.数据表示为元组:
std::tuple<uint8_t, int32_t> data;
size_t bufferIndex;
IOBuffer::ConstSPtr buffer( std::make_shared<IOBuffer>(5) );
我也有元组heplers迭代元组并为每个元素执行一个仿函数:
//-------------------------------------------------------------------------
//
template <typename Function, typename ...Tuples, typename ...Args>
void IterateOverTuple( Function& f, std::tuple<Tuples...>& t,
Args&... args )
{
impl::IterateOverTupleImpl<0, sizeof...(Tuples),
std::tuple<Tuples...>>()( f, t, args... );
}
//---------------------------------------------------------------------
//
template <int I, size_t TSize, typename Tuple>
struct IterateOverTupleImpl
: public IterateOverTupleImpl<I + 1, TSize, Tuple>
{
template <typename Function, typename ...Args>
void operator()( Function& f, Tuple& t, Args&... args )
{
f( std::get<I>(t), args... );
IterateOverTupleImpl<I + 1, TSize, …我有一个恒定的元组向量，其中每个元组都包含一个键，名称，数量，值。这就是我的定义方式-
// tuple of key, name, quantity, value
const std::vector<std::tuple<unsigned char, std::string, unsigned char, float> > myTable{
std::tuple<unsigned char, std::string, unsigned char, float>(0, "mango", 12, 1.01f),
std::tuple<unsigned char, std::string, unsigned char, float>(4, "apple", 101, 22.02f),
std::tuple<unsigned char, std::string, unsigned char, float>(21, "orange", 179, 39.03f),
};
在main函数中，我需要每个元组的索引和所有值进行处理。为简单起见，我使用以下方式打印它们：
for (int index = 0; index < myTable.size(); index++) {
auto key = std::get<0>(myTable[index]);
auto name = std::get<1>(myTable[index]);
auto quantity = std::get<2>(myTable[index]);
auto value = std::get<3>(myTable[index]);
std::cout << " index: " << index
<< …