Question

标题几乎说明了一切。我想这样做：

std::pair<int,int> a(2,1), b(1,1), c(0,0);
c=a-b;

得到c =（1,0）。如果它涉及定义一个新的类并且操作符重载，我想，我仍然有兴趣看到最优雅的方式来做到这一点，但它会更好，imo，如果有的话非增强，非新类定义解决方案。谢谢！ -Mark

Answer 1

std::valarray旨在支持向量的数值计算（即有序的数字序列）。

std::valarray<int> a {2, 1}, b {1, 1}, c;
c = a - b;

您可以使用下标运算符std::vector访问其元素，就像访问[]，即的元素一样。

Answer 2

您可以随时编写自己的运算符：

std::pair<int, int> operator+(const std::pair<int, int>& a, 
    const std::pair<int, int>& b)
{
    return std::make_pair(a.first + b.first, a.second + b.second);
}

// other operators here

std::pair<int,int> a(2,1), b(1,1);
auto c = a + b; // yields (3,2)

甚至可以在整数序列的帮助下推广到任意元组（有很多地方可以查找如何执行此操作）：

template <size_t I, typename... T>
typename std::tuple_element<I, std::tuple<T...>>::type
addi(const std::tuple<T...>&a, const std::tuple<T...>&b)
{
    return std::get<I>(a) + std::get<I>(b);
}

template <size_t... I, typename... T>
std::tuple<T...> add(sequence<I...>, const std::tuple<T...>&a, const std::tuple<T...>&b)
{
    return std::make_tuple(addi<I>(a,b)...);
}


template <typename... T>
std::tuple<T...> operator+(const std::tuple<T...>& a, const std::tuple<T...>& b)
{
    return add(typename gen_sequence<sizeof...(T)>::type{}, a, b); 
}


std::tuple<int, int, int> ta{1, 1, 2};
std::tuple<int, int, int> tb{2, 2, 2};

auto tc = ta + tb; // yields <3, 3, 4>

Answer 3

您不需要新课程，您可以定义全局免费功能模板，如下所示：

template<typename T>
std::pair<T,T> operator - (const std::pair<T,T> & lhs, const std::pair<T,T> & rhs)
{
    return std::pair<T,T>(lhs.first - rhs.first, lhs.second - rhs.second);
}

int main(int argc, char * argv[])
{
    (void)argc; (void)argv;

    std::pair<int,int> a(2,1), b(1,1), c(0,0);
    c=a-b;
    return 0;
}

是否有一种优雅的方式在c ++中对元组（例如，对）进行算术运算？

3 个答案: