Come posso creare una stringa alfanumerica casuale in C ++?

Mi piacerebbe creare una stringa casuale, composta da caratteri alfanumerici. Voglio essere in grado di specificare la lunghezza della stringa.

Come faccio questo in C ++?

La risposta di Mehrdad Afshari avrebbe funzionato, ma l’ho trovata un po ‘troppo prolissa per questo semplice compito. Le tabelle di ricerca a volte possono fare miracoli:

void gen_random(char *s, const int len) { static const char alphanum[] = "0123456789" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz"; for (int i = 0; i < len; ++i) { s[i] = alphanum[rand() % (sizeof(alphanum) - 1)]; } s[len] = 0; } 

Ecco il mio adattamento della risposta di Ates Goral usando C ++ 11. Ho aggiunto il lambda qui, ma il principio è che potresti passarlo e quindi controllare quali caratteri contiene la stringa:

 std::string random_string( size_t length ) { auto randchar = []() -> char { const char charset[] = "0123456789" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz"; const size_t max_index = (sizeof(charset) - 1); return charset[ rand() % max_index ]; }; std::string str(length,0); std::generate_n( str.begin(), length, randchar ); return str; } 

Ecco un esempio di passaggio di un lambda alla funzione di stringa casuale: http://ideone.com/Ya8EKf

Perché dovresti usare C ++ 11 ?

  1. Perché puoi produrre stringhe che seguono una certa distribuzione di probabilità (o combinazione di distribuzione) per il set di caratteri che ti interessa.
  2. Perché ha il supporto integrato per numeri casuali non deterministici
  3. Perché supporta l’unicode, quindi puoi cambiarlo in una versione internazionalizzata.

Per esempio:

 #include  #include  #include  #include  //for std::function #include  //for std::generate_n typedef std::vector char_array; char_array charset() { //Change this to suit return char_array( {'0','1','2','3','4', '5','6','7','8','9', 'A','B','C','D','E','F', 'G','H','I','J','K', 'L','M','N','O','P', 'Q','R','S','T','U', 'V','W','X','Y','Z', 'a','b','c','d','e','f', 'g','h','i','j','k', 'l','m','n','o','p', 'q','r','s','t','u', 'v','w','x','y','z' }); }; // given a function that generates a random character, // return a string of the requested length std::string random_string( size_t length, std::function rand_char ) { std::string str(length,0); std::generate_n( str.begin(), length, rand_char ); return str; } int main() { //0) create the character set. // yes, you can use an array here, // but a function is cleaner and more flexible const auto ch_set = charset(); //1) create a non-deterministic random number generator std::default_random_engine rng(std::random_device{}()); //2) create a random number "shaper" that will give // us uniformly distributed indices into the character set std::uniform_int_distribution<> dist(0, ch_set.size()-1); //3) create a function that ties them together, to get: // a non-deterministic uniform distribution from the // character set of your choice. auto randchar = [ ch_set,&dist,&rng ](){return ch_set[ dist(rng) ];}; //4) set the length of the string you want and profit! auto length = 5; std::cout< 

Uscita di esempio

La mia soluzione 2p:

 #include  #include  std::string random_string(std::string::size_type length) { static auto& chrs = "0123456789" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; thread_local static std::mt19937 rg{std::random_device{}()}; thread_local static std::uniform_int_distribution pick(0, sizeof(chrs) - 2); std::string s; s.reserve(length); while(length--) s += chrs[pick(rg)]; return s; } 
  void gen_random(char *s, const int len) { for (int i = 0; i < len; ++i) { int randomChar = rand()%(26+26+10); if (randomChar < 26) s[i] = 'a' + randomChar; else if (randomChar < 26+26) s[i] = 'A' + randomChar - 26; else s[i] = '0' + randomChar - 26 - 26; } s[len] = 0; } 

Tendo ad usare sempre i modi strutturati di C ++ per questo tipo di inizializzazione. Si noti che, fondamentalmente, non è diverso dalla soluzione di Altan. Per un programmatore C ++, esprime semplicemente l’intento un po ‘meglio e potrebbe essere più facile da trasportare su altri tipi di dati. In questo caso, la funzione C ++ generate_n esprime esattamente ciò che desideri:

 struct rnd_gen { rnd_gen(char const* range = "abcdefghijklmnopqrstuvwxyz0123456789") : range(range), len(std::strlen(range)) { } char operator ()() const { return range[static_cast(std::rand() * (1.0 / (RAND_MAX + 1.0 )) * len)]; } private: char const* range; std::size_t len; }; std::generate_n(s, len, rnd_gen()); s[len] = '\0'; 

A proposito, leggi il saggio di Julienne sul perché questo calcolo dell’indice è preferito rispetto a metodi più semplici (come prendere il modulo).

Ho appena provato questo, funziona dolcemente e non richiede una tabella di ricerca. rand_alnum () sorta di forzare alfanumerici ma perché seleziona 62 di 256 caratteri possibili non è un grosso problema.

 #include  // for rand() #include  // for isalnum() #include  // for back_inserter #include  char rand_alnum() { char c; while (!std::isalnum(c = static_cast(std::rand()))) ; return c; } std::string rand_alnum_str (std::string::size_type sz) { std::string s; s.reserve (sz); generate_n (std::back_inserter(s), sz, rand_alnum); return s; } 

Spero che questo aiuti qualcuno.

Testato su https://www.codechef.com/ide con C ++ 4.9.2

 #include  #include  #include  /* srand, rand */ using namespace std; string RandomString(int len) { srand(time(0)); string str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; string newstr; int pos; while(newstr.size() != len) { pos = ((rand() % (str.size() - 1))); newstr += str.substr(pos,1); } return newstr; } int main() { string random_str = RandomString(100); cout << "random_str : " << random_str << endl; } 

Output: random_str : DNAT1LAmbJYO0GvVo4LGqYpNcyK3eZ6t0IN3dYpHtRfwheSYipoZOf04gK7OwFIwXg2BHsSBMB84rceaTTCtBC0uZ8JWPdVxKXBd

Qualcosa di ancora più semplice e basilare nel caso in cui sei contento che la tua stringa contenga caratteri stampabili:

 #include  // we'll use time for the seed #include  // this is for strcpy void randomString(int size, char* output) // pass the destination size and the destination itself { srand(time(NULL)); // seed with time char src[size]; size = rand() % size; // this randomises the size (optional) src[size] = '\0'; // start with the end of the string... // ...and work your way backwards while(--size > -1) src[size] = (rand() % 94) + 32; // generate a string ranging from the space character to ~ (tilde) strcpy(output, src); // store the random string } 

Ecco un divertente one-liner. Ha bisogno di ASCII.

 void gen_random(char *s, int l) { for (int c; c=rand()%62, *s++ = (c+"07="[(c+16)/26])*(l-->0);); } 

Stringa casuale, ogni file di esecuzione = stringa diversa

  auto randchar = []() -> char { const char charset[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz"; const size_t max_index = (sizeof(charset) - 1); return charset[randomGenerator(0, max_index)]; }; std::string custom_string; size_t LENGTH_NAME = 6 // length of name generate_n(custom_string.begin(), LENGTH_NAME, randchar); 

Esempio per l’uso Qt 🙂

 QString random_string(int length=32, QString allow_symbols=QString("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")) { QString result; qsrand(QTime::currentTime().msec()); for (int i = 0; i < length; ++i) { result.append(allow_symbols.at(qrand() % (allow_symbols.length()))); } return result; } 
 #include  #include  #include  std::string generateRandomId(size_t length = 0) { static const std::string::value_type allowed_chars[] {"123456789BCDFGHJKLMNPQRSTVWXZbcdfghjklmnpqrstvwxz"}; static thread_local std::default_random_engine randomEngine(std::random_device{}()); static thread_local std::uniform_int_distribution randomDistribution(0, sizeof(allowed_chars) - 1); std::string id(length ? length : 32, '\0'); for (std::string::value_type& c : id) { c = allowed_chars[randomDistribution(randomEngine)]; } return id; } int main() { std::cout << generateRandomId() << std::endl; } 
 #include  #include  template void genRandomString(char (&buffer)[N]) { std::random_device rd; const char alphanumeric[] = { "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" }; std::mt19937 eng(rd()); std::uniform_int_distribution<> distr(0, 61); for (auto& c : buffer) c = alphanumeric[distr(eng)]; buffer[N] = '\0'; } int main() { char buffer[100]; // 99 is the string length genRandomString(buffer); std::cout << buffer << '\n'; return 0; } 

Be ware quando si chiama la funzione

 string gen_random(const int len) { static const char alphanum[] = "0123456789" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; stringstream ss; for (int i = 0; i < len; ++i) { ss << alphanum[rand() % (sizeof(alphanum) - 1)]; } return ss.str(); } 

(adattato da @Ates Goral ) produrrà sempre la stessa sequenza di caratteri. Uso

 srand(time(NULL)); 

prima di chiamare la funzione, sebbene la funzione rand () sia seminata sempre con 1 @kjfletch .

Per esempio:

 void SerialNumberGenerator() { srand(time(NULL)); for (int i = 0; i < 5; i++) { cout << gen_random(10) << endl; } } 
 void strGetRandomAlphaNum(char *sStr, unsigned int iLen) { char Syms[] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; unsigned int Ind = 0; srand(time(NULL) + rand()); while(Ind < iLen) { sStr[Ind++] = Syms[rand()%62]; } sStr[iLen] = '\0'; }