[英]Nested parameter pack expansion
請參見下面的代碼段(矩陣乘法的實現)。
是否可以使用嵌套包擴展來簡化它們,例如
{{((a[r][k] * b[k][c]) + ...)...}...}
?
#include <array>
#include <utility>
template<typename T, size_t R, size_t C>
using Matrix = std::array<std::array<T, C>, R>;
template<typename A, typename B>
using mul_el_t = decltype(std::declval<A>()[0][0] * std::declval<B>()[0][0]);
計算單個元素的助手。
template<size_t R1, size_t C2, size_t... C1_R2, typename A, typename B>
auto _mat_mul_element(const A &a, const B &b, std::index_sequence<C1_R2...>)
{
return ((a[R1][C1_R2] * b[C1_R2][C2]) + ...);
}
計算特定行的助手。
template<size_t R1, size_t... C2, typename C1_R2, typename A, typename B>
auto _mat_mul_row(const A &a, const B &b, std::index_sequence<C2...>, C1_R2 c1_r2)
-> std::array<mul_el_t<A, B>, sizeof...(C2)>
{
return {_mat_mul_element<R1, C2>(a, b, c1_r2)...};
}
這使用參數包來計算整個矩陣。
template<size_t... R1, typename C2, typename C1_R2, typename A, typename B>
auto _mat_mul(const A &a, const B &b, std::index_sequence<R1...>, C2 c2, C1_R2 c1_r2)
-> Matrix<mul_el_t<A, B>, sizeof...(R1), C2::size()>
{
return {_mat_mul_row<R1>(a, b, c2, c1_r2)...};
}
和實際的界面。
template<typename T, size_t R1, size_t C1_R2, size_t C2>
Matrix<T, R1, C2> operator*(const Matrix<T, R1, C1_R2> &a, const Matrix<T, C1_R2, C2> &b)
{
return _mat_mul(
a, b,
std::make_index_sequence<R1>{},
std::make_index_sequence<C2>{},
std::make_index_sequence<C1_R2>{}
);
};
更新 (看起來我不清楚我所遇到的實際問題)
當我嘗試將_mat_mul
替換為:
template<size_t... R1, size_t... C2, size_t... C1_R2, typename A, typename B>
auto _mat_mul(const A &a, const B &b,
std::index_sequence<R1...>,
std::index_sequence<C2...>,
std::index_sequence<C1_R2...>)
-> Matrix<mul_el_t<A, B>, sizeof...(R1), sizeof...(C2)>
{
return {{((a[R1][C1_R2] * b[C1_R2][C2]) + ...)...}...};
}
使用Apple LLVM version 9.1.0 (clang-902.0.39.1)
編譯失敗並顯示以下信息:
[ 50%] Building CXX object CMakeFiles/main.cpp.o
main.cpp:38:51: error: pack expansion does not contain any unexpanded parameter packs
return {{((a[R1][C1_R2] * b[C1_R2][C2]) + ...)...}...};
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^
我認為失敗是預料之中的,因為編譯器不知道在每個擴展塊中要擴展哪個包( R1
, C2
或C1_R2
)。 在這種情況下,如何提示編譯器(注意,我可以使用任何編譯器)?
根據文檔,嵌套的包擴展可以看作是從最里面的包擴展[3點]開始的迭代過程。 每個包擴展都會擴展該包擴展所包含的子表達式內的所有參數包。
因此, {{((a[R1][C1_R2] * b[C1_R2][C2]) + ...)...}...}
變為
{{(a[0][0] * b[0][0] + a[1][1] * b[1][1])...}...}
( R1/C2/C1_R2
是index_sequence<2>
)。 因此,接下來的兩包擴展沒有任何擴展。
可以將每個參數包同時移動到所需的子表達式,而將實際值保留在所需位置。 let ... in
表達式中,可以使用FP let ... in
類似物:
auto let = [](auto a, auto f) { return f(a); };
因此,原始表達式變為:
{let(R1, [&](auto r1) {
return std::array<T, sizeof...(C2)>{let(C2, [&](auto c2) {
return ((a[r1][C1_R2] * b[C1_R2][c2]) + ...);
})...};
})...};
那可能已經足夠好了,但是可能需要一些時間來解釋那里發生的事情。 同樣,仍然需要在范圍內引入那些參數包。
可以嘗試通過對參數包的引入/擴展進行抽象來提高可讀性。 使用以下實用程序功能。
template<typename H, typename F, typename T, T... I>
decltype(auto) repack(std::integer_sequence<T, I...>, H h, F f)
{
return h(f(std::integral_constant<T, I>{})...);
}
此函數的值帶有某個包(可以對std::integer_sequence
以外的值進行重載),應用於包的每個元素的函數f
和用於將最終包轉換為某個值的函數h
。
因此,全乘法例程成為
template<typename T, size_t R1, size_t C1_R2, size_t C2>
Matrix<T, R1, C2> operator*(const Matrix<T, R1, C1_R2> &a, const Matrix<T, C1_R2, C2> &b)
{
std::make_index_sequence<R1> r1{};
std::make_index_sequence<C2> c2{};
std::make_index_sequence<C1_R2> c1_r2{};
return repack(r1, ctor<Matrix<T, R1, C2>>(), [&](auto r1) {
return repack(c2, ctor<std::array<T, C2>>(), [&](auto c2) {
return repack(c1_r2, sum, [&](auto c1_r2) {
return a[r1][c1_r2] * b[c1_r2][c2];
});
});
});
}
ctor
在哪里
template<typename H>
auto ctor()
{
return [](auto... xs) { return H{xs...}; };
}
和sum = [](auto... xs) { return (xs +...); };
sum = [](auto... xs) { return (xs +...); };
。
一個表達式中可能帶有三個嵌套repack
的點模式,因此乘法例程可能變為:
template<typename T, size_t R1, size_t C1_R2, size_t C2>
Matrix<T, R1, C2> operator*(const Matrix<T, R1, C1_R2> &a, const Matrix<T, C1_R2, C2> &b)
{
auto item = [&](auto r1, auto c2, auto c1_r2) { return a[r1][c1_r2] * b[c1_r2][c2]; };
auto curried_repack = curry(POLY(repack));
auto m = curried_repack(std::make_index_sequence<R1>{}, ctor<Matrix<T, R1, C2>>());
auto r = curried_repack(std::make_index_sequence<C2>{}, ctor<std::array<T, C2>>());
auto e = curried_repack(std::make_index_sequence<C1_R2>{}, sum);
auto op = [](auto w, auto f) {
return compose(w, curry(f));
};
return foldr(op, m, r, e, item)();
}
使用實用程序:
template<typename F>
auto curry(F f)
{
return [=](auto... a) {
return [=](auto... b) { return f(a..., b...); };
};
};
template<typename F, typename G>
auto compose(F f, G g)
{
return [=](auto... xs) {
return f(g(xs...));
};
};
和宏將模板功能轉化為價值
#define POLY(f) ([](auto... a){ return f(a...); })
而foldr
其留作家庭作業。
從意義上講,所有解決方案在生成相同的二進制文件時都是等效的。
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.