如何在C ++(c ++ 11/c ++ 17)中执行元组算术? [英] How to perform tuple arithmetic in C++ (c++11/c++17)?
问题描述
我正在尝试编写模板功能/运算符，例如+，以便在两个相同类型的元组之间进行算术运算.例如，对于
I'm trying to write template functions/operators such as + for doing arithmetic operations between two tuples of the same type. For example, for
std::tuple<int,double> t = std::make_tuple(1,2);
我想做
auto t1 = t + t;
逻辑很简单:按元素进行算术运算.但是我不知道如何在c ++模板编程(c ++ 11/17)中实现这一功能.我下面的代码无法使用g++ -std=c++11 tuple_arith.cpp进行编译.特别是，我无法弄清楚使通用add函数(template<typename T> T add(T x, T y) { return x + y; })与元组操纵代码一起工作的正确方法.
The logic is simple: to do the arithmetic element-wise. But I can't figure out how to make this work in c++ template programming (c++11/17). My code below doesn't compile with g++ -std=c++11 tuple_arith.cpp. In particular, I can't figure out the right way of getting the generic add function (template<typename T> T add(T x, T y) { return x + y; }) to work with the tuple manipulating code.
有人可以帮忙解释如何解决此问题吗?
#include <tuple>
namespace std {
template<typename _Tp, size_t __i, size_t __size, typename _opT >
struct __tuple_arith {
static constexpr _Tp __op(const _Tp& __t, const _Tp& __u, const _opT& op) {
return std::tuple_cat(std::make_tuple(op(std::get<__i>(__t), std::get<__i>(__u))
, __tuple_arith<_Tp, __i + 1, __size, _opT>::__op(__t, __u)));
}
};
template<typename _Tp, size_t __size, typename _opT>
struct __tuple_arith<_Tp, __size, __size - 1, _opT> {
static constexpr _Tp __op(const _Tp& __t, const _Tp& __u, const _opT& op) {
return std::make_tuple(op(std::get<__size-1>(__t), std::get<__size -1>(__u)));
}
};
template<typename T> T add(T x, T y) { return x + y; }
template<typename... _TElements> constexpr tuple<_TElements...>
operator+(const tuple<_TElements...>& __t, const tuple<_TElements...>& __u) {
using op = __tuple_arith<tuple<_TElements...>, 0, sizeof...(_TElements), decltype(add)>;
return op::__op(__t, __u, add);
}
}; //namespace std
#include <iostream>
using namespace std;
int main() {
std::tuple<int,double> t = std::make_tuple(1,2);
auto t1 = t + t;
cout << std::get<0>(t1) << std::endl;
return 0;
}
具体错误是:
tuple_arith.cpp:14:10: error: template argument ‘(__size - 1)’ involves template parameter(s)
struct __tuple_arith<_Tp, __size, __size - 1, _opT> {
^
tuple_arith.cpp: In function ‘constexpr std::tuple<_Elements ...> std::operator+(const std::tuple<_Elements ...>&, const std::tuple<_Elements ...>&)’:
tuple_arith.cpp:24:90: error: decltype cannot resolve address of overloaded function
__tuple_arith<tuple<_TElements...>, 0, sizeof...(_TElements), decltype(add)>;
^
tuple_arith.cpp:24:91: error: template argument 4 is invalid
__tuple_arith<tuple<_TElements...>, 0, sizeof...(_TElements), decltype(add)>;
^
tuple_arith.cpp:25:12: error: ‘op’ has not been declared
return op::__op(__t, __u, add);
^
tuple_arith.cpp: In instantiation of ‘constexpr std::tuple<_Elements ...> std::operator+(const std::tuple<_Elements ...>&, const std::tuple<_Elements ...>&) [with _TElements = {int, double}]’:
tuple_arith.cpp:34:17: required from here
tuple_arith.cpp:26:3: error: body of constexpr function ‘constexpr std::tuple<_Elements ...> std::operator+(const std::tuple<_Elements ...>&, const std::tuple<_Elements ...>&) [with _TElements = {int, double}]’ not a return-statement
}
^
-更新-
感谢您到目前为止提供的有用答案.是否有可能使其适用于任何操作员包装器，例如std::{plus,minus,multiplies,divides}?这就是我试图通过模板参数typename _opT实现的目标.最后，我正在寻找可以将兼容运算符作为参数的函数/对象.
Thanks for the helpful answers so far. Is it possible to make it work for any Operator Wrappers, e.g. std::{plus,minus,multiplies,divides}? That's what I was trying to achieve with the template parameter typename _opT. In the end, I'm looking for a function/object that can take a compatible Operator as a parameter.
推荐答案
您的代码中的问题是，您无法基于另一个模板值对模板值进行部分专业化处理.您可以解决这个问题，但是...为什么?
The problem in your code is that you cannot partial specialize a template value based over another template value; you can go round this problem but... why?
用std::index_sequence
#include <tuple>
#include <iostream>
template <typename ... Ts, std::size_t ... Is>
std::tuple<Ts...> sumT (std::tuple<Ts...> const & t1,
std::tuple<Ts...> const & t2,
std::index_sequence<Is...> const &)
{ return { (std::get<Is>(t1) + std::get<Is>(t2))... }; }
template <typename ... Ts>
std::tuple<Ts...> operator+ (std::tuple<Ts...> const & t1,
std::tuple<Ts...> const & t2)
{ return sumT(t1, t2, std::make_index_sequence<sizeof...(Ts)>{}); }
int main ()
{
std::tuple<int,double> t = std::make_tuple(1,2);
auto t1 = t + t;
std::cout << std::get<0>(t1) << std::endl;
std::cout << std::get<1>(t1) << std::endl;
}
无论如何...我不认为将操作符添加到标准类型不是一个好主意.也许您只能定义一个sumT()函数.
Anyway... I don't think it's a good idea add operators to standard types; maybe you can only define a sumT() function.
P.s .: std::index_sequence和std::make_index_sequence是c ++ 14/17的功能；但不太复杂，可以在c ++ 11中对其进行仿真.
P.s.: std::index_sequence and std::make_index_sequence are c++14/17 features; but isn't too complex simulate they in c++11.
-编辑-
OP询问
非常感谢，是否可以使任何操作程序包装程序都可以使用此功能?请查看更新
Thanks a lot, is it possible to make this work for any operators wrappers? Please see the update
我想你的意思如下
#include <tuple>
#include <iostream>
#include <functional>
template <typename Op, typename Tp, std::size_t ... Is>
auto opH2 (Op const & op, Tp const & t1, Tp const & t2,
std::index_sequence<Is...> const &)
{ return std::make_tuple( op(std::get<Is>(t1), std::get<Is>(t2))... ); }
template <typename Op, typename Tp>
auto opH1 (Op const & op, Tp const & t1, Tp const & t2)
{ return opH2(op, t1, t2,
std::make_index_sequence<std::tuple_size<Tp>{}>{}); }
template <typename ... Ts>
auto operator+ (std::tuple<Ts...> const & t1, std::tuple<Ts...> const & t2)
{ return opH1(std::plus<>{}, t1, t2); }
template <typename ... Ts>
auto operator- (std::tuple<Ts...> const & t1, std::tuple<Ts...> const & t2)
{ return opH1(std::minus<>{}, t1, t2); }
template <typename ... Ts>
auto operator* (std::tuple<Ts...> const & t1, std::tuple<Ts...> const & t2)
{ return opH1(std::multiplies<>{}, t1, t2); }
template <typename ... Ts>
auto operator/ (std::tuple<Ts...> const & t1, std::tuple<Ts...> const & t2)
{ return opH1(std::divides<>{}, t1, t2); }
int main ()
{
std::tuple<int,double> t = std::make_tuple(1,2);
auto t1 = t + t;
auto t2 = t - t;
auto t3 = t * t;
auto t4 = t / t;
std::cout << std::get<0>(t1) << ", " << std::get<1>(t1) << std::endl;
std::cout << std::get<0>(t2) << ", " << std::get<1>(t2) << std::endl;
std::cout << std::get<0>(t3) << ", " << std::get<1>(t3) << std::endl;
std::cout << std::get<0>(t4) << ", " << std::get<1>(t4) << std::endl;
}
这篇关于如何在C ++(c ++ 11/c ++ 17)中执行元组算术?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
