两个参数包C++之间的communi类型

Question

我需要定义带有2个参数的和之后的返回类型(代码中的？？？(！我的目标是定义一个元组类(比如std:：Tuple(，并在这里实现例如，在两个相同长度和兼容类型的元组之间的加法(，这里有一个代码片段需要理解：

template<class FirstType, class ... Types>
class Tuple{
....
template <typename ... OtherTypes>
const Tuple<????> operator+(Tuple<OtherTypes...>& other) const{...}
... 
}

问题在于；int+double"；例如，应该还给我一个替身！我看了看std:：common_type，但也没看到。元组构造如下：

private:
FirstType m_first ;
Tuple<Types...> m_next ;

m_first包含该值，m_next通过移除一个值来包含下一个元组。

这是我存储不同类型的方法，尽管还有另一种方法是遗传方法。我有另一个类，它有一个递归情况的模板。

所以我不知道如何获得最终的返回类型，我有一个get函数，其中我使用了getHelper<gt；结构返回正确的类型，但这里又不同了。我不想使用AUTO，这会给我带来问题，也不是魔法。

提前感谢您的回答。

示例：Tuple<int，双精度>(3,4.4(+簇<双，双>(3.1，3.1(=元组<DOUBLE，DOUBLE>(6.5,7.5(

Answer 1

请参阅此处了解如何元素添加两个元组https://stackoverflow.com/a/50815600/4117728.以下内容建立在这个答案的基础上。剩下要添加的只是获得公共类型元组：

template <typename T1,typename T2>
struct common_tuple;
template <typename...T1,typename...T2>
struct common_tuple< std::tuple<T1...>,std::tuple<T2...>> {
using type = std::tuple<std::common_type_t<T1,T2>...>;
};

然后可以将上面链接的答案调整为：

namespace internal
{    
template<typename T,typename S, size_t... Is>
common_tuple<T,S>::type add_rhs_to_lhs(T& t1, const S& t2, std::integer_sequence<size_t, Is...>)
{
return std::make_tuple( (std::get<Is>(t1) + std::get<Is>(t2))... );      
}
}
template <typename...T,typename...S>
std::tuple<std::common_type_t<T,S>...> operator + (std::tuple<T...> lhs, const std::tuple<S...>& rhs)
{
return internal::add_rhs_to_lhs(lhs, rhs, std::index_sequence_for<T...>{});
}

int main(int argc, char *argv[])
{
auto a = std::make_tuple(1,2,4);
auto b = std::make_tuple(1.0,2.0,4.0);
auto c = a + b;
std::cout << std::get<0>(c) << "n";
std::cout << std::get<1>(c) << "n";
std::cout << std::get<2>(c) << "n";
}

然而，a + b已经产生了公共类型，因此您可以简单地使用auto:

#include <tuple>
#include <iostream>

namespace internal
{    
template<typename T,typename S, size_t... Is>
auto add_rhs_to_lhs(T& t1, const S& t2, std::integer_sequence<size_t, Is...>)
{
return std::make_tuple( (std::get<Is>(t1) + std::get<Is>(t2))... );      
}
}
template <typename...T,typename...S>
auto operator + (std::tuple<T...> lhs, const std::tuple<S...>& rhs)
{
return internal::add_rhs_to_lhs(lhs, rhs, std::index_sequence_for<T...>{});
}

int main(int argc, char *argv[])
{
auto a = std::make_tuple(1,2,4);
auto b = std::make_tuple(1.0,2.0,4.0);
auto c = a + b;
std::cout << std::get<0>(c) << "n";
std::cout << std::get<1>(c) << "n";
std::cout << std::get<2>(c) << "n";
}