Question

我是range-v3库的一个完整的初学者。.假设我想在某个间隔中用随机数填充std::array。

使用迭代器，我会做类似this answer的事情，将迭代器作为参数传递给有问题的std::array。

template< class Iter >
void fill_with_random_int_values( Iter start, Iter end, int min, int max)
{
    static std::random_device rd;    // you only need to initialize it once
    static std::mt19937 mte(rd());   // this is a relative big object to create

    std::uniform_int_distribution<int> dist(min, max);

    std::generate(start, end, [&] () { return dist(mte); });
}

对于ranges库，我想使用ranges::view::generate_n，并使用一元函数来生成一个随机数以及数组的大小。

auto random_num() -> int {
  static std::mt19937 engine{std::random_device{}()};
  static std::uniform_int_distribution<int> dist(1, 10);
  return dist(engine);
}

std::vector<int> nums = ranges::view::generate_n(random_num, 10);

这对于std::vector来说效果很好，但是我很困惑应该使用哪种算法来填充std::array而不是生成std::vector，就像上面的类似方法不起作用。我可以transform数组并忽略每个参数，但这似乎不正确。

Answer 1

std::array的大小是一个编译时常量，因此我看不到该库如何使用运行时参数为您生成一个。

这是一个相当琐碎的实现，我认为它可以满足您的需求：

#include <random>
#include <array>
#include <utility>
#include <iostream>

auto random_num() -> int {
  static std::mt19937 engine{std::random_device{}()};
  static std::uniform_int_distribution<int> dist(1, 10);
  return dist(engine);
}

template<class F, std::size_t...Is>
auto generate_array_impl(F&& f, std::index_sequence<Is...>) -> std::array<decltype(f()), sizeof...(Is)>
{
    return std::array<decltype(f()), sizeof...(Is)>
    {{
        (void(Is), f())...
    }};
}

template<std::size_t N, class F>
auto generate_array(F f) -> std::array<decltype(f()), N>
{
    return generate_array_impl(f, std::make_index_sequence<N>());
}


int main()
{
    auto arr = generate_array<10>(random_num);
    for (auto x : arr)
    std::cout << x << '\n';
}

https://coliru.stacked-crooked.com/a/983064b89c4dd355

或添加一些constexpr魔术...

#include <random>
#include <array>
#include <utility>
#include <iostream>
#include <boost/range.hpp>

template<std::size_t N>
constexpr auto c_size_t = std::integral_constant<std::size_t, N>();

auto random_num() -> int {
  static std::mt19937 engine{std::random_device{}()};
  static std::uniform_int_distribution<int> dist(1, 10);
  return dist(engine);
}

template<class F, std::size_t...Is>
constexpr auto generate_array_impl(F&& f, std::index_sequence<Is...>) -> std::array<decltype(f()), sizeof...(Is)>
{
    return std::array<decltype(f()), sizeof...(Is)>
    {{
        (void(Is), f())...
    }};
}

template<std::size_t N, class F>
constexpr auto generate_array(F&& f, std::integral_constant<std::size_t, N>) -> std::array<decltype(f()), N>
{
    return generate_array_impl(f, std::make_index_sequence<N>());
}

int main()
{
    auto arr = generate_array(random_num, c_size_t<10>);
    for (auto x : arr)
        std::cout << x << ',';
    std::cout << '\n';

    constexpr auto arr2 = generate_array([i = std::size_t(0)]() mutable { return i++; }, c_size_t<10>);
    for (auto x : arr2)
        std::cout << x << ',';
    std::cout << '\n';
}

https://coliru.stacked-crooked.com/a/42c9c011026779eb

Answer 2

std::array是一个汇总；它没有用户提供的构造函数。因此，它没有从范围创建对象的构造函数。

您也不能（在C ++ 17中）编写一个接受范围并返回数组的函数。原因是参数不是constexpr，并且数组的大小必须是一个常量表达式。 C ++ 20似乎增加了将更多类型作为非类型模板参数的功能，因此应该有可能将其作为模板参数。代码如下：

template<auto rng>
    requires std::ranges::SizedRange<decltype(rng)>
constexpr auto array_from_range()
{
  std::array<std::iter_value_t<rng>, std::ranges::size(rng)> ret;
  std::ranges::copy(rng, ret);
  return ret;
}

当然，这要求范围本身是constexpr，而不仅仅是大小。

Answer 3

由于数组的大小是编译时常量。您必须自己构建它。您可以像这样填充它

std::array<int, 10> arr;
ranges::generate(arr, random_num);

如何使用范围-v3填充std :: array？

3 个答案: