两个参数包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_类型的一面，但我也看不到。元组的构造如下：

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

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

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

所以我不知道如何获取最终的返回类型，我有一个get函数，在这里我使用了一个getHelper

提前感谢您的回答。

示例：Tuple

Answer 1

看这里如何elementwise添加两个元组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";
}

但是，ab已经生成了通用类型，因此您可以简单地使用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";
}