通過使用std :: get，std :: tuple_size，std :: tuple_element

Question

來加總一個元組的元素我有一個具有類似tuple的接口的自定義類。因爲我希望我的代碼儘可能通用，所以我認爲將我的算法基於函數std::get，std::tuple_size,std::tuple_element是一個好主意，因此您只需專門使用這些函數即可使用我的算法。讓我們稱之爲需要這些功能專業化的概念Tuple。

現在我試圖總結一個Tuple的組件。該函數聲明應該是這樣的：

template <class Tuple> 
int sum_components(const Tuple& t); 

我想，有很多涉及模板編程，但我無法弄清楚如何做到這一點。

另外，我只是使用全球+ operator的超載。

我正在使用C++ 1z。

Answer 1

這在c++17中非常容易。

template<class Tuple> 
decltype(auto) sum_components(Tuple const& tuple) { 
    auto sum_them = [](auto const&... e)->decltype(auto) { 
    return (e+...); 
    }; 
    return std::apply(sum_them, tuple); 
}; 

或(...+e)表示相反的摺疊方向。

在以前的版本中，正確的方法是編寫自己的apply，而不是編寫定製的實現。當你的編譯器更新時，你可以刪除代碼。

在c++14，我可以這樣做：

// namespace for utility code: 
namespace utility { 
    template<std::size_t...Is> 
    auto index_over(std::index_sequence<Is...>) { 
    return [](auto&&f)->decltype(auto){ 
     return decltype(f)(f)(std::integral_constant<std::size_t,Is>{}...); 
    }; 
    } 
    template<std::size_t N> 
    auto index_upto() { 
    return index_over(std::make_index_sequence<N>{}); 
    } 
} 
// namespace for semantic-equivalent replacements of `std` code: 
namespace notstd { 
    template<class F, class Tuple> 
    decltype(auto) apply(F&& f, Tuple&& tuple) { 
    using dTuple = std::decay_t<Tuple>; 
    auto index = ::utility::index_upto< std::tuple_size<dTuple>{} >(); 
    return index([&](auto...Is)->decltype(auto){ 
     auto target=std::ref(f); 
     return target(std::get<Is>(std::forward<Tuple>(tuple))...); 
    }); 
    } 
} 

這是相當接近std::apply在c++14。 （我濫用std::ref得到INVOKE語義）。 （它並不適用於右值調用者，但這是非常特殊的情況）。

在c++11，我建議此時升級你的編譯器。在c++03我建議現在升級你的工作。

---

以上所有內容都是右對齊或左對齊。在某些情況下，二叉樹摺疊可能會更好。這很棘手。

如果您的+執行表達式模板，則由於生存期問題，上述代碼將無法正常工作。在某些情況下，您可能需要添加另一個模板類型「之後，轉換爲」以使臨時表達式樹進行評估。

Answer 2

使用C++ 1z，它非常簡單，用fold expressions。首先，元組轉發到_impl函數並提供它與索引序列來訪問所有元組的元素，然後總和：

template<typename T, size_t... Is> 
auto sum_components_impl(T const& t, std::index_sequence<Is...>) 
{ 
    return (std::get<Is>(t) + ...); 
} 

template <class Tuple> 
int sum_components(const Tuple& t) 
{ 
    constexpr auto size = std::tuple_size<Tuple>{}; 
    return sum_components_impl(t, std::make_index_sequence<size>{}); 
} 

demo

---

A C++ 14的方法是遞歸地總結一個可變參數包：

int sum() 
{ 
    return 0; 
} 

template<typename T, typename... Us> 
auto sum(T&& t, Us&&... us) 
{ 
    return std::forward<T>(t) + sum(std::forward<Us>(us)...); 
} 

template<typename T, size_t... Is> 
auto sum_components_impl(T const& t, std::index_sequence<Is...>) 
{ 
    return sum(std::get<Is>(t)...); 
} 

template <class Tuple> 
int sum_components(const Tuple& t) 
{ 
    constexpr auto size = std::tuple_size<Tuple>{}; 
    return sum_components_impl(t, std::make_index_sequence<size>{}); 
} 

demo

C++ 11方法將是定製實現index_sequence的C++ 14方法。例如從here。

---

由於@ildjarn在評論中指出，上述例子都採用正確的褶皺，而許多程序員希望在他們的代碼左倍。 C++的1Z版本是平凡多變：

template<typename T, size_t... Is> 
auto sum_components_impl(T const& t, std::index_sequence<Is...>) 
{ 
    return (... + std::get<Is>(t)); 
} 

demo

而C++ 14不是差很多，但也有更多的變化：

template<typename T, typename... Us> 
auto sum(T&& t, Us&&... us) 
{ 
    return sum(std::forward<Us>(us)...) + std::forward<T>(t); 
} 

template<typename T, size_t... Is> 
auto sum_components_impl(T const& t, std::index_sequence<Is...>) 
{ 
    constexpr auto last_index = sizeof...(Is) - 1; 
    return sum(std::get<last_index - Is>(t)...); 
} 

demo