prevent multiple copies within function with static - c++

Question

I've a function to generate random characters from a set of alphabets. This function would be called multiple times and thus I'm trying to make it use same set of variables, ie have same seed so that strings don't repeat as long as possible.
#include <iostream>
#include <random>
#include <string>
std::string generateRandomChar(const unsigned int _len)
{
std::string result;
result.reserve(_len);
static constexpr char alphanum[] = "0123456789"
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, 61);
for (int i = 0; i < _len;
result += (alphanum[dis(gen)]);
}
return result;
}
int main(){
for(int i = 0; i < 10; ++i){
std::cout << generateRandomChar(10) << std::endl;
}
}
Unfortunately I don't have any expertise with c++11 functions and I was only using srand and friends earlier, so I might be making lots of mistakes here. Currently it works and generates tons of strings without repeating, but I'm sure I could make either of -
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, 61);
static variable too, so that it isn't calculated each time the function is called because that would be waste right?
So which one should be static here? Are there any mistakes/improvements that you see here?
Thankyou :D
edit - here's an ideone link - http://ideone.com/e7ssXo

Answer 1

So which one should be static here?
Either std::mt19937 gen or none of them.
std::random_device generates uniformly-distributed random integers using non-deterministic entropy source, if available. Your code uses std::random_device output as a seed for std::mt19937 pseudo-random generator. So you are very likely to have good, non-deterministic seeds for std::mt19937 if you run on a PC, and thus there is no need to make any of them static. I suppose that std::random_device is implemented as a pure-procedural PRNG only on low-end controllers.
On the other hand, one-time seeding is more idiomatic, so you may declare std::mt19937 as static. std::mt19937 itself implements a high-quality PRNG algorithm with 19937 bits of state, so it's period probably exceeds the Universe lifetime (or at least the stelliferous era), if the generator is running on a modern PC.
There is no need to make std::uniform_int_distribution static, as it's only a wrapper which modifies actual generator's output according to desired distribution properties. So it's up to you to decide whether make it static or not.

Answer 2

To allow unit test, I suggest to move the generator outside of the function, something like
std::string generateRandomChar(const unsigned int len, std::mt19937& gen)
{
std::string result;
result.reserve(len);
static constexpr char alphanum[] = "0123456789"
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
std::uniform_int_distribution<> dis(0, 61);
for (int i = 0; i < len; ++i) {
result += (alphanum[dis(gen)]);
}
return result;
}
int main() {
std::random_device rd;
std::mt19937 gen(rd());
for (int i = 0; i < 10; ++i) {
std::cout << generateRandomChar(10, gen) << std::endl;
}
}
or create a class
class RandomCharGenerator
{
public:
RandomCharGenerator() : RandomCharGenerator(std::random_device{}()) {}
template <typename T>
RandomCharGenerator(T&& seed) : gen(std::forward<T>(seed)) {}
std::string operator() (const unsigned int len)
{
std::string result;
result.reserve(len);
for (int i = 0; i < len; ++i) {
result += (alphanum[dis(gen)]);
}
return result;
}
private:
std::mt19937 gen;
std::uniform_int_distribution<> dis{0, 61};
static constexpr char alphanum[] = "0123456789"
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
};
int main() {
RandomCharGenerator charGenerator{};
for (int i = 0; i < 10; ++i) {
std::cout << charGenerator(10) << std::endl;
}
}
You can eventually templated things to allow other rand generator.

Answer 3

You can make your random_device and mt19937 static. Currently you are constructing one everytime the function is called (IIRC, mt19937 is expensive to construct. Someone corect me). Also, your uniform_int_distribution can be moved out of the loop. This question is better suited for codereview as it already works and you are looking for improvements.
TL;DR: You can make all of them static.