7

使用range-v3 库（由@EricNiebler 编写），使编写算法代码更加紧凑，例如，这里是如何生成一堆随机数：

#include <range/v3/all.hpp>
#include <iostream>
#include <vector>

int main() 
{
    using namespace ranges;

    auto const N = 10;
    std::vector<int> v; 
    v.reserve(N);

    v |= action::push_back(view::iota(0, N)); 
    random_shuffle(v);
    copy(v, ostream_iterator<>(std::cout, ","));
}

活生生的例子。

但是，我更愿意用这样的假设来扩展action::random_shuffle()管道

v |= action::push_back(view::iota(0, N)) | action::random_shuffle();

这是我编写这样一个动作的尝试（不幸的是，编写新的 range-v3 代码比使用库要冗长得多）

#include <functional> // bind, placeholders::_1

namespace ranges
{
    inline namespace v3
    {
        /// \addtogroup group-actions
        /// @{
        namespace action
        {
            struct random_shuffle_fn
            {
            private:
                friend action_access;

                static auto bind(random_shuffle_fn random_shuffle)
                RANGES_DECLTYPE_AUTO_RETURN
                (
                    std::bind(random_shuffle, std::placeholders::_1)
                )

                template<typename Gen>
                static auto bind(random_shuffle_fn random_shuffle, Gen && rand)
                RANGES_DECLTYPE_AUTO_RETURN
                (
                    std::bind(random_shuffle, std::placeholders::_1, bind_forward<Gen>(rand))
                )
            public:
                struct ConceptImpl
                {
                    template<typename Rng,
                        typename I = range_iterator_t<Rng>>
                    auto requires_(Rng&&) -> decltype(
                        concepts::valid_expr(
                            concepts::model_of<concepts::RandomAccessRange, Rng>(),
                            concepts::is_true(Permutable<I>())
                        ));
                };

                template<typename Rng>
                using Concept = concepts::models<ConceptImpl, Rng>;

                template<typename Rng,
                    CONCEPT_REQUIRES_(Concept<Rng>())>
                Rng operator()(Rng && rng) const
                {
                    ranges::random_shuffle(rng);
                    return std::forward<Rng>(rng);
                }

                template<typename Rng, typename Gen,
                    CONCEPT_REQUIRES_(Concept<Rng>())>
                Rng operator()(Rng && rng, Gen && rand) const
                {
                    ranges::random_shuffle(rng, std::forward<Gen>(rand));
                    return std::forward<Rng>(rng);
                }

                #ifndef RANGES_DOXYGEN_INVOKED
                template<typename Rng>
                void operator()(Rng &&) const
                {
                    CONCEPT_ASSERT_MSG(RandomAccessRange<Rng>(),
                        "The object on which action::random_shuffle operates must be a model of the "
                        "RandomAccessRange concept.");
                    using I = range_iterator_t<Rng>;
                    CONCEPT_ASSERT_MSG(Permutable<I>(),
                        "The iterator type of the range passed to action::random_shuffle must allow its "
                        "elements to be permuted; that is, the values must be movable and the "
                        "iterator must be mutable.");
                }
            #endif
            };

            /// \ingroup group-actions
            /// \relates sort_fn
            /// \sa `action`
            namespace
            {
                constexpr auto&& random_shuffle = static_const<action<random_shuffle_fn>>::value;
            }
        }
        /// @}
    }
}

无法编译的实时示例operator()，因为没有找到一些深藏在某处的东西。

据我所知，我忠实地从类似代码中翻译了上述代码，例如action::sort(). 唯一的区别是random_shuffle()有两个重载（一个采用随机生成器），而所有其他动作（包括sort）都有一个重载，其额外参数（比较器、谓词、投影仪等）具有默认值。这转化为上面的两个bind()静态成员函数random_shuffle_fn，而所有其他操作只有一个bind()重载。

问题：如何为 random_shuffle 编写 range-v3 动作？

4

2 回答 2

3

你有两个模棱两可的重载random_shuffle_function::operator()(Rng&&)，你的“错误捕获”重载需要被限制为只接受那些正确的重载拒绝的参数（我们真的需要 C++ 概念，所以我再也不需要 SFINAE 约束重载）：

#ifndef RANGES_DOXYGEN_INVOKED
template<typename Rng,
    CONCEPT_REQUIRES_(!Concept<Rng>())>
void operator()(Rng &&) const
{
    CONCEPT_ASSERT_MSG(RandomAccessRange<Rng>(),
        "The object on which action::random_shuffle operates must be a model of the "
        "RandomAccessRange concept.");
    using I = range_iterator_t<Rng>;
    CONCEPT_ASSERT_MSG(Permutable<I>(),
        "The iterator type of the range passed to action::random_shuffle must allow its "
        "elements to be permuted; that is, the values must be movable and the "
        "iterator must be mutable.");
}
#endif

此外，您需要通过管道action::random_shuffle：

v |= action::push_back(view::iota(0, N)) | action::random_shuffle;

演示

于 2015-05-24T17:24:19.980 回答
3

来自 git 的最新版本已经包含action::shuffle. 它可以按如下方式使用：

#include <random>
std::mt19937 gen;
...
v |= action::push_back(view::iota(0, N)) | action::shuffle(gen);
于 2015-05-26T15:39:45.790 回答