如何让自定义随机函数适配std::shuffle？原std::random_shuffle已弃用

std::shuffle 和已弃用的 std::random_shuffle 对随机数生成器的要求完全不同：

• std::random_shuffle 接受形如 int rand(int n) 的函数，返回 [0,n) 区间的随机数
• std::shuffle 要求传入符合UniformRandomBitGenerator（URBG）概念的类型，必须满足：
  • 定义 result_type 为无符号整数类型
  • 提供静态成员函数 min() 和 max()，返回生成值的范围边界
  • 实现 operator()，无参数且返回 result_type 类型的随机数

你的 myRand::RandInt 适配了 random_shuffle 的接口，但不符合 URBG 的要求，因此调用 std::shuffle 会报错。

把现有逻辑封装成类，让它满足 URBG 规范，同时保留模拟/真实随机的切换能力：

#include <random>
#include <vector>
#include <iostream>
#include <cstdint>

namespace myRand {
    bool simulatingRandom = false;
    std::vector<uint32_t> secuenciaPseudoRandom = {1, 0, 1, 0};
    size_t index = 0;

    class RandEngine {
    public:
        // URBG 要求的返回类型
        using result_type = uint32_t;

        // 静态成员：返回生成值的范围边界
        static constexpr result_type min() { return 0; }
        static constexpr result_type max() { return UINT32_MAX; }

        // 核心调用运算符，生成随机数
        result_type operator()() {
            if (simulatingRandom) {
                if (index >= secuenciaPseudoRandom.size()) {
                    index = 0;
                    std::cout << "Warning: myRand resetting sequence" << std::endl;
                }
                return secuenciaPseudoRandom[index++];
            } else {
                // 用C++标准库的随机数生成器替代rand()，随机性更可靠
                static std::mt19937 real_engine(std::random_device{}());
                return real_engine();
            }
        }
    };

    // 保留原RandInt接口，兼容旧的random_shuffle调用
    int RandInt(int i) {
        return static_cast<int>(RandEngine{}() % i);
    }
}

// 调用示例
int main() {
    std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9};

    // 真实随机模式下使用std::shuffle
    std::shuffle(v.begin(), v.end(), myRand::RandEngine{});

    // 切换到模拟模式测试
    myRand::simulatingRandom = true;
    std::shuffle(v.begin(), v.end(), myRand::RandEngine{});

    return 0;
}

• 封装成 RandEngine 类，严格遵循 URBG 的所有要求
• 模拟序列改用 uint32_t，与 URBG 的返回类型一致
• 真实随机模式替换为 std::mt19937，避免 rand() 分布不均、周期短的缺陷
• 保留原 RandInt 函数，兼容之前基于 random_shuffle 的代码

• 避免全局状态：把 index 和模拟序列移到 RandEngine 的成员变量中，避免多线程冲突和测试隔离问题。可以给类加构造函数，允许传入自定义模拟序列：

  class RandEngine {
  private:
      std::vector<result_type> local_sequence;
      size_t local_index = 0;
  public:
      RandEngine() = default;
      // 传入自定义模拟序列
      explicit RandEngine(std::vector<result_type> seq) : local_sequence(std::move(seq)) {}
  
      result_type operator()() {
          if (simulatingRandom) {
              auto& seq = local_sequence.empty() ? secuenciaPseudoRandom : local_sequence;
              if (local_index >= seq.size()) {
                  local_index = 0;
                  std::cout << "Warning: myRand resetting sequence" << std::endl;
              }
              return seq[local_index++];
          } else {
              static std::mt19937 real_engine(std::random_device{}());
              return real_engine();
          }
      }
  };
  

• 用测试框架Mock随机输出：如果是单元测试，使用Google Test等框架的Mock功能直接控制随机数返回值，比维护固定模拟序列更灵活。
• 隔离测试环境：测试时单独设置模拟模式，避免影响生产代码的随机逻辑，测试完成后重置状态。

内容的提问来源于stack exchange，提问作者MarcosP