多类型Visitor Variant的随机值生成问题（兼容VS2015U3、GCC4.9）

问题背景 #

你提到想借助variant的visitor模式处理多种数值类型并生成随机值，但受限于旧编译器（无法使用VS2015 Update3或GCC4.9及之后版本），只能依赖mpark::variant这个C++11/14兼容的variant实现。现有代码基础如下：

std::random_device randomDevice;
std::mt19937 randomEngine(randomDevice());
typedef mpark::variant<
    bool,
    int8_t, uint8_t,
    int16_t, uint16_t,
    int32_t, uint32_t,
    int64_t, uint64_t,
    float, double,
    std::string
> MyVariant;

解决方案：实现兼容旧编译器的Visitor #

由于旧编译器不支持C17的std::visit，我们可以利用mpark::variant本身兼容C11/14的visitor机制——通过定义一个仿函数，为每种目标类型重载operator()来生成对应随机值。

步骤1：定义随机生成Visitor #

创建一个仿函数，针对每种类型实现随机值生成逻辑：

struct RandomGeneratorVisitor {
    std::mt19937& engine;

    explicit RandomGeneratorVisitor(std::mt19937& eng) : engine(eng) {}

    // 生成随机bool值
    bool operator()(bool) const {
        std::bernoulli_distribution dist;
        return dist(engine);
    }

    // 生成有符号8位整数随机值
    int8_t operator()(int8_t) const {
        std::uniform_int_distribution<int8_t> dist(INT8_MIN, INT8_MAX);
        return dist(engine);
    }

    // 生成无符号8位整数随机值
    uint8_t operator()(uint8_t) const {
        std::uniform_int_distribution<uint8_t> dist(0, UINT8_MAX);
        return dist(engine);
    }

    // 生成有符号16位整数随机值
    int16_t operator()(int16_t) const {
        std::uniform_int_distribution<int16_t> dist(INT16_MIN, INT16_MAX);
        return dist(engine);
    }

    // 生成无符号16位整数随机值
    uint16_t operator()(uint16_t) const {
        std::uniform_int_distribution<uint16_t> dist(0, UINT16_MAX);
        return dist(engine);
    }

    // 生成有符号32位整数随机值
    int32_t operator()(int32_t) const {
        std::uniform_int_distribution<int32_t> dist(INT32_MIN, INT32_MAX);
        return dist(engine);
    }

    // 生成无符号32位整数随机值
    uint32_t operator()(uint32_t) const {
        std::uniform_int_distribution<uint32_t> dist(0, UINT32_MAX);
        return dist(engine);
    }

    // 生成有符号64位整数随机值
    int64_t operator()(int64_t) const {
        std::uniform_int_distribution<int64_t> dist(INT64_MIN, INT64_MAX);
        return dist(engine);
    }

    // 生成无符号64位整数随机值
    uint64_t operator()(uint64_t) const {
        std::uniform_int_distribution<uint64_t> dist(0, UINT64_MAX);
        return dist(engine);
    }

    // 生成float类型随机值（范围可自定义）
    float operator()(float) const {
        std::uniform_real_distribution<float> dist(-1e6f, 1e6f);
        return dist(engine);
    }

    // 生成double类型随机值（范围可自定义）
    double operator()(double) const {
        std::uniform_real_distribution<double> dist(-1e12, 1e12);
        return dist(engine);
    }

    // 生成随机字符串（字符集、长度可自定义）
    std::string operator()(const std::string&) const {
        const char charset[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        const size_t strLength = 10;
        std::string result;
        result.reserve(strLength);
        std::uniform_int_distribution<size_t> dist(0, sizeof(charset) - 2);
        for (size_t i = 0; i < strLength; ++i) {
            result += charset[dist(engine)];
        }
        return result;
    }
};

步骤2：使用Visitor生成随机Variant #

编写一个工具函数，传入一个带类型标识的variant实例，通过mpark::visit触发visitor生成对应类型的随机值：

MyVariant generateRandomVariant(const MyVariant& typeHint) {
    RandomGeneratorVisitor visitor(randomEngine);
    return mpark::visit(visitor, typeHint);
}

步骤3：调用示例 #

你可以通过传入对应类型的空variant来指定要生成的随机值类型：

// 生成随机int32_t类型值
MyVariant randomInt = generateRandomVariant(MyVariant(int32_t{}));
// 生成随机std::string类型值
MyVariant randomStr = generateRandomVariant(MyVariant(std::string{}));

注意事项 #

• 确保已正确引入mpark::variant的头文件，若为静态库版本需链接对应库文件。
• 浮点类型的随机范围、字符串的字符集和长度，可根据实际业务需求灵活调整。
• 旧编译器需要开启C++11支持：VS2015需添加编译选项/std:c++11，GCC需添加-std=c++11。

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