c++ 随机

Singleton.h

#pragma once
#include <cassert>


template <class T>
class Singleton
{
public:
    Singleton()
    {
        assert(!ms_pSingleton);
        ms_pSingleton = static_cast<T*>(this);
    }

    ~Singleton()
    {
        assert(ms_pSingleton);
        ms_pSingleton = nullptr;
    }

    static T* Instance()
    {
        return ms_pSingleton;
    }

private:
    Singleton(const Singleton<T> &) = delete;
    Singleton& operator = (const Singleton<T> &) = delete;
protected:
    static T *ms_pSingleton;
};

template <class T>
T *Singleton<T>::ms_pSingleton = nullptr;

Random.h

#pragma once
#include <random>
#include <map>

#include "Singleton.h"

struct RandomCreater
{
    long randomSeed();
    void init();
    int random(int begin, int end);

    std::mt19937 *mt = nullptr;
    int useCount = 0;
    long seed = 0;
};


class Random : public Singleton<Random>
{
public:
    Random();
    ~Random();
    int random(int begin, int end, std::string createName = "");
private:
    std::map<std::string, std::shared_ptr<RandomCreater>> m_allRandomCreater;
    std::shared_ptr<RandomCreater> m_defaultCreater;
};

Random.cpp

#include "Random.h"

long RandomCreater::randomSeed()
{
    std::random_device rd;
    return rd();
}

void RandomCreater::init()
{
    if (seed == 0 || useCount > 1000)
    {
        seed = randomSeed();
        useCount = 0;
        if (mt != nullptr)
            delete mt;

        mt = new std::mt19937(seed);
    }
}

int RandomCreater::random(int begin, int end)
{
    if (begin == end) return begin;

    int min = begin < end ? begin : end;
    int max = begin < end ? end : begin;

    int rt = (*mt)() % (abs(max - min));
    rt = rt + min;

    return rt;
}


Random::Random()
{
    m_defaultCreater = std::make_shared<RandomCreater>();
    m_defaultCreater->init();
}

Random::~Random()
{
}

int Random::random(int begin, int end, std::string createName)
{
    std::shared_ptr<RandomCreater> useCreater = m_defaultCreater;
    if (!createName.empty())
    {
        if (m_allRandomCreater.find(createName) == m_allRandomCreater.end())
        {
            m_allRandomCreater[createName] = std::make_shared<RandomCreater>();
        }

        useCreater = m_allRandomCreater[createName];
    }
    useCreater->init();
    useCreater->useCount++;
    return useCreater->random(begin, end);
}

main.cpp

#include <iostream>
#include "Random.h"

int main(int argc, char* argv[])
{
    new Random();
    std::cout << Random::Instance()->random(-100, 100);

    getchar();

    return 0;
}