随机数模板

今天我写了几个随机数的函数，在这里分享给大家：

#include <random>
#include <stdexcept>
#include <iostream>
#include <chrono>
#include <cstring>
template <typename T>
using enable_if_integer = typename std::enable_if<std::is_integral<T>::value, T>::type;
unsigned long long generate_seed() {
    static std::random_device rd;
    auto time_seed = static_cast<unsigned long long>(
        std::chrono::high_resolution_clock::now().time_since_epoch().count()
    );
    return rd() ^ time_seed;
}
std::mt19937_64& get_random_engine() {
    thread_local static std::mt19937_64 engine(generate_seed());
    return engine;
}
template <typename T>
enable_if_integer<T> randrange(T start, T stop, T step) {
    if (step == 0) {
        throw std::invalid_argument("randrange() step argument must not be zero");
    }
    T n;
    if (step > 0) {
        if (stop <= start) {
            throw std::invalid_argument("randrange() empty range for start, stop, step");
        }
        n = (stop - start - 1) / step + 1;
    } else {
        if (stop >= start) {
            throw std::invalid_argument("randrange() empty range for start, stop, step");
        }
        if (step == std::numeric_limits<T>::min()) {
            using unsigned_type = typename std::make_unsigned<T>::type;
            unsigned_type abs_step = static_cast<unsigned_type>(std::numeric_limits<T>::max()) + 1;
            n = (static_cast<unsigned_type>(start) - 
                 static_cast<unsigned_type>(stop) - 1) / abs_step + 1;
        } else {
            n = (start - stop - 1) / (-step) + 1;
        }
    }
    if (n <= 0) {
        throw std::invalid_argument("randrange() empty range");
    }
    thread_local static std::mt19937_64 engine(generate_seed());
    if (n == 1) {
        return start;
    }
    if (n <= static_cast<T>(std::numeric_limits<uint32_t>::max())) {
        std::uniform_int_distribution<uint32_t> dist(0, static_cast<uint32_t>(n-1));
        T k = dist(engine);
        return start + k * step;
    } else {
        std::uniform_int_distribution<T> dist(0, n-1);
        T k = dist(engine);
        return start + k * step;
    }
}
template <typename T>
enable_if_integer<T> randrange(T start, T stop) {
    return randrange(start, stop, static_cast<T>(1));
}
template <typename T>
enable_if_integer<T> randrange(T stop) {
    return randrange(static_cast<T>(0), stop, static_cast<T>(1));
}
template <typename T>
enable_if_integer<T> randint(T a, T b) {
    if (a > b) {
        throw std::invalid_argument("randint() a must be less than or equal to b");
    }
    return randrange(a, static_cast<T>(b + 1));
}
char* randstring(size_t len, const char* char_set = "abcdefghijklmnopqrstuvwxyz") {
    if (len == 0) {
        char* result = new char[1];
        result[0] = '\0';
        return result;
    }
    if (char_set == nullptr || char_set[0] == '\0') {
        throw std::invalid_argument("randstring: character set must not be empty");
    }
    size_t char_set_len = strlen(char_set);
    
    auto& engine = get_random_engine();
    std::uniform_int_distribution<size_t> dist(0, char_set_len - 1);
    char* result = new char[len + 1];
    for (size_t i = 0; i < len; i++) {
        result[i] = char_set[dist(engine)];
    }
    result[len] = '\0';
    return result;
}
char* randstring(size_t min_len, size_t max_len, const char* char_set = "abcdefghijklmnopqrstuvwxyz") {
    if (min_len > max_len) {
        throw std::invalid_argument("randstring: min_len must be less than or equal to max_len");
    }
    size_t len = randint(min_len, max_len);
    return randstring(len, char_set);
}

int main() {
	std::cout << "Testing randstring (fixed length):\n";
    char* s1 = randstring(5);
    std::cout << "5 chars: " << s1 << std::endl;
    
    char* s2 = randstring(10, "0123456789");
    std::cout << "10 digits: " << s2 << std::endl;
    
    char* s3 = randstring(8, "0123456789ABCDEF");
    std::cout << "8 hex chars: " << s3 << std::endl;
    
    std::cout << "\nTesting randstring (variable length):\n";
    char* s4 = randstring(3, 7);
    std::cout << "3-7 chars: " << s4 << std::endl;
    
    char* s5 = randstring(5, 10, "0123456789");
    std::cout << "5-10 digits: " << s5 << std::endl;
    
    std::cout << "\nEdge cases:\n";
    char* s6 = randstring(0);
    std::cout << "Zero length: '" << s6 << "'" << std::endl;
    
    char* s7 = randstring(10, "A");
    std::cout << "Single char set: " << s7 << std::endl;
    
    try {
        std::cout << "\nTesting empty char set: ";
        char* s8 = randstring(5, "");
        std::cout << s8 << std::endl; // 这行不会执行
    } catch (const std::invalid_argument& e) {
        std::cout << "Caught: " << e.what() << std::endl;
    }
    
    try {
        std::cout << "Testing min_len > max_len: ";
        char* s9 = randstring(10, 5);
        std::cout << s9 << std::endl; // 这行不会执行
    } catch (const std::invalid_argument& e) {
        std::cout << "Caught: " << e.what() << std::endl;
    }
	return 0;
}