c++ - 在可变模板参数上实现数学补码逻辑

Question

我有一个定义 constexpr size_t dimensions 的类.在这门课中，我实现了一个 EvaluateOver<Dimensions...>(Lambda F)它在我指定的维度上做了一些事情。例如，说 dimensions=4和 f是一些 lambda 表达式:

MyClass.EvaluateOver<0,2>(f);

将执行 f通过执行以下扩展关于 0 和 2:

template<size_t... Dims, typename Lambda>
inline auto EvaluateOver(const Lambda& F) const
{
    F(std::get<Dims>(_memberTupleDataContainer)...);
}

现在我想要另一个成员函数来评估未指定的维度。所以EvaluateOverOthers<0,2>(f)将在维度 1 和维度 3 上执行操作。

理想情况下，我正在考虑以下内容:

template<size_t... Dims, typename Lambda>
inline auto EvaluateOverOthers(const Lambda& F) const
{
    EvaluateOver<
            // variadic parameter that does the mathematical complement of
            // Dims... with a variadic expansion of dimensions
            >(F);
}

Answer 1

以下内容可能会有所帮助:

namespace details
{

template <typename Seq1, typename Seq2, typename Res = std::index_sequence<>>
struct minus;

// Nothing more to remove
template <std::size_t ... Is1, std::size_t... IRes>
struct minus<std::index_sequence<Is1...>,
             std::index_sequence<>,
             std::index_sequence<IRes...>>
{
    using type = std::index_sequence<IRes..., Is1...>;
};

// Remove front elements as they are equal.
template <std::size_t I, std::size_t ... Is1, std::size_t ... Is2, std::size_t... IRes>
struct minus<std::index_sequence<I, Is1...>,
             std::index_sequence<I, Is2...>,
             std::index_sequence<IRes...>>
{
    using type = typename minus<std::index_sequence<Is1...>,
                                std::index_sequence<Is2...>,
                                std::index_sequence<IRes...>>::type;
};

// Add front element to result.
template <std::size_t I1, std::size_t I2,
          std::size_t ... Is1, std::size_t ... Is2,
          std::size_t... IRes>
struct minus<std::index_sequence<I1, Is1...>,
             std::index_sequence<I2, Is2...>,
             std::index_sequence<IRes...>>
{
    using type = typename minus<std::index_sequence<Is1...>,
                                std::index_sequence<I2, Is2...>,
                                std::index_sequence<IRes..., I1>>::type;
};

}

template <std::size_t N, typename Seq>
using complement = details::minus<std::make_index_sequence<N>, Seq>;

template <std::size_t N, typename Seq>
using complement_t = typename complement<N, Seq>::type;

// Some test
static_assert(std::is_same<std::index_sequence<0, 3>,
                    complement_t<4, std::index_sequence<1, 2>>>::value, "!");

然后

template<size_t... Is, typename Lambda>
auto EvaluateOver(const Lambda& F, std::index_sequence<Is...>) const
{
    return F(std::get<Is>(_memberTupleDataContainer)...);
}

template<size_t... Dims, typename Lambda>
auto EvaluateOver(const Lambda& F) const
{
    return EvaluateOver(F, std::index_sequence<Is...>{});
}

template<size_t... Is, typename Lambda>
auto EvaluateOverOthers(const Lambda& F) const
{
    return EvaluateOver(F, complement_t<_dimension, std::index_sequence<Is...>>{});
}