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

Question

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

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

问题是“int + double" 应该返回一个 double 例如！我查看了 std::common_type 一侧，但我也没有看到。 元组的构造如下：

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

m_first 包含值，并且， m_next 通过删除一个值来包含下一个元组。

这是我存储不同类型的方法，尽管还有另一种采用遗传方法的方法。 我有另一个带有递归案例模板的类。

所以我不知道如何获取最终的返回类型，我有一个 get 函数，其中使用了 getHelper<...>结构返回正确的类型，但这里又不同了。我不想使用自动，这会给我带来问题，而且这并不神奇。

预先感谢您的答复。

示例：元组(3,4.4) + 元组(3.1,3.1) = 元组(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 已经产生通用类型，因此您可以简单地使用 自动：

#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";
}