Encapsulating boost :: random pour la facilité d'utilisation pour remplacer rand()

Question

pour mon programme J'ai besoin d'entiers pseudo-aléatoires avec différentes plages. Jusqu'à présent, j'ai utilisé la fonction rand() mais elle a ses limites.

J'ai trouvé que la bibliothèque boost :: random était un bien meilleur remplacement, mais je ne voulais pas créer de générateurs aléatoires partout.
(J'ai besoin d'entiers aléatoires dans de nombreuses classes, parce que c'est un logiciel de test de stress qui rend chaque décision pseudo-aléatoire (-> un test doit être répétable en définissant le même départ)).

C'est pourquoi j'ai capsuled boost :: random dans ma propre classe.

L'idée est de faciliter l'utilisation de sorte qu'il est presque aussi simple que la méthode rand C++()

#include "boost/shared_ptr.hpp" 
#include "boost/random.hpp" 

class Random{ 
public: 
    typedef boost::shared_ptr<Random> randomPtr; 
    typedef boost::mt19937 randomGeneratorType; 

    static randomPtr Get(){ 
     static randomPtr randomGen(new RandomGenerator()); 
     return randomGen; 
    } 

    void SetSeed(int seed){ 
     randomGenerator.seed(seed); 
    } 

    int Random(int lowerLimit, int upperLimit){ 
    boost::uniform_int<> distribution(lowerLimit, upperLimit); 
    boost::variate_generator< randomGeneratorType&, boost::uniform_int<> > 
    LimitedInt(randomGenerator , distribution); 
    return LimitedInt(); 
    } 

private: 
    // prevent creation of more than one object of the LogManager class 
    // use the Get() method to get a shared_ptr to the object 
    Random(): 
    randomGenerator() //initialize randomGenerator with default constructor 
    {} 

    RandomGenerator(const RandomGenerator& orig){}; 

    randomGeneratorType randomGenerator; 
}; 

La génération d'un nombre aléatoire dans une plage donnée sera désormais aussi facile que

#include "Random.h" 
    Random::Get()->SetSeed(123123); // If you want to make the run repeatable 
    int dice = Random::Get()->Random(1,6); 

question:
y at-il quelque chose de mal avec cette façon de générer des nombres aléatoires?
Grand frais généraux que je n'ai pas reconnu?
Pure Technique de programmation périmée ou périmée?

(je suis encore nouveau pour C++ et que vous souhaitez améliorer mes compétences, et je l'ai trouvé que Stack overflow est le meilleur endroit pour obtenir des conseils de haute qualité)

Answer 1

Joe Gauterin a démontré la question, mais il n'a pas offert aucune solution :)

Le problème avec l'état partagé est l'absence de reentrance: par exemple, exécuter deux fois la même méthode ne fournit pas la même résultat.Ceci est particulièrement critique dans les situations multithread, car l'état global peut ne pas toujours changer au même point dans le programme, conduisant ainsi à des résultats incohérents d'un passage à l'autre. La solution est que chaque simulation devrait avoir son propre "état" et que vous évitiez l'état partagé. Ceci peut être accompli de plusieurs façons: vous pouvez toujours utiliser un état "global" mais le rendre local à un thread, par exemple, ainsi les threads ne marcheront pas sur les autres orteils. La version plus propre consiste cependant à stocker cet état quelque part, et la plus simple est d'avoir une classe Context, instanciée une fois par simulation, et qui est un agrégat de l'état de la simulation (pour la simulation). état large).

Avec cela à l'esprit:

class Context 
{ 
public: 
    typedef boost::mt19937 RandomGeneratorType; 

    void SetSeed(int seed){ 
    rg.seed(seed); 
    } 

    int Next(int lowerLimit, int upperLimit) { 
    boost::uniform_int<> distribution(lowerLimit, upperLimit); 
    boost::variate_generator< randomGeneratorType&, boost::uniform_int<> > 
    LimitedInt(rg, distribution); 
    return LimitedInt(); 
    } 

private: 
    RandomGeneratorType rg; 
}; 

Ensuite, passer le Context par exemple autour de votre simulation, et vous pouvez exécuter autant que vous le souhaitez en parallèle.

Answer 2

Je dirais que cela ressemble bien - De cette façon, vous pouvez facilement remplacer votre algo de génération aléatoire en cas de besoin.

Answer 3

Vous avez essentiellement enveloppé votre générateur dans un singleton, introduisant tous les problèmes que les singletons et les variables globales portent. Par exemple, vous auriez des difficultés à exécuter plusieurs tests de stress en parallèle, car votre implémentation n'est pas sécurisée pour les threads.

Mais le principal problème que je vois est que votre wrapper n'est pas plus simple que d'utiliser boost :: random sans le wrapper.

Answer 4

Vous pouvez probablement éviter Get(). C'est purement subjectif, pour moi. Je préférerais un mécanisme d'appel comme Random::Seed() et Random::Next() ou Random::Next(min,max). Il n'y a pas trop de fonctions dans Random, donc vous pouvez leur faire toutes les fonctions statiques.

Voici une implémentation simple. Mais gardez à l'esprit que c'est en considérant que vous utilisez ceci dans un environnement mono-thread. Pour un environnement multithread, il est préférable de ne pas l'utiliser comme un singleton.

class Random 
{ 
public: 
    typedef boost::mt19937 RandomGeneratorType; 

    static void Seed(int seed) 
    { 
     s_randGen.seed(seed); 
    } 

    static int NextInt(int min_val, int max_val) 
    { 
     boost::uniform_int<> distribution(min_val, max_val);boost::variate_generator< randomGeneratorType&, boost::uniform_int<> > 
     return LimitedInt(s_randGen , distribution);; 
    } 
private: 
    static RandomGeneratorType s_randGen; 
}; 

Random::RandomGeneratorType Random::s_randGen; 

Answer 5

Vous pouvez également essayer quelque chose comme créer une entité dans un conteneur et les mélanger au hasard.

void 
GenerateRandomString(vector<string>& container, 
        int size_of_string, 
        unsigned long long num_of_records, 
        int thread_id) 
{ 
    srandom(time(0)); 
    random(); 
    for(unsigned long long int i=0; i < num_of_records; ++i) 
    { 
    stringstream str_stream; 
    str_stream.clear(); 
    str_stream << left << setfill('x') << setw(size_of_string-4); 
    str_stream << num_of_records+i+1 << "-" << thread_id; 
    container.push_back(str_stream.str()); 
    } 
    random_shuffle(container.begin(), container.end()); 
} 

Answer 6

Ci-dessous est ma version d'encapsulation:

#include <boost/random.hpp> 
#include <ctime> 


int getRandomIntValue(int min, int max) 
{ 
    static boost::minstd_rand gen((unsigned int)std::time(NULL)); 
    boost::uniform_int<int> dist(min, max); 
    boost::variate_generator< 
     boost::minstd_rand&, 
     boost::uniform_int<int>> combgen(gen, dist); 

    return combgen(); 
}