Wie erstelle ich eine zufällige alphanumerische Zeichenfolge in C ++?

Ich möchte eine zufällige Zeichenfolge erstellen, die aus alphanumerischen Zeichen besteht. Ich möchte in der Lage sein, die Länge der Zeichenfolge anzugeben.

Wie mache ich das in C ++?

Solutions Collecting From Web of "Wie erstelle ich eine zufällige alphanumerische Zeichenfolge in C ++?"

Mehrdad Afsharis Antwort würde den Trick machen, aber ich fand es für diese einfache Aufgabe etwas zu ausführlich. Look-up-Tabellen können manchmal Wunder bewirken:

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; } 

Hier ist meine Adaption der Antwort von Ates Goral mit C ++ 11. Ich habe das Lambda hier hinzugefügt, aber das Prinzip ist, dass Sie es übergeben können und dadurch steuern, welche Zeichen Ihre Zeichenfolge enthält:

 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; } 

Hier ist ein Beispiel für die Übergabe eines Lambda an die zufällige String-function: http://ideone.com/Ya8EKf

Warum würden Sie C ++ 11 verwenden ?

  1. Weil Sie Zeichenfolgen erzeugen können, die einer bestimmten Wahrscheinlichkeitsverteilung (oder Verteilungskombination) für den Zeichensatz folgen, an dem Sie interessiert sind.
  2. Weil es eingebaute Unterstützung für nicht-deterministische Zufallszahlen hat
  3. Weil es Unicode unterstützt, könnten Sie dies in eine internationalisierte Version ändern.

Beispielsweise:

 #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<  

Beispielausgabe

Meine 2p Lösung:

 #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; } 

Ich neige dazu, immer die strukturierten C ++ – Möglichkeiten für diese Art von Initialisierung zu verwenden. Beachten Sie, dass es im Grunde genommen nicht anders ist als Altans Lösung. Für einen C ++ – Programmierer drückt es nur die Absicht etwas besser aus und ist möglicherweise leichter zu anderen Datentypen übertragbar. In diesem Fall drückt die C ++ – function generate_n genau aus, was Sie wollen:

 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'; 

Lesen Sie übrigens Juliennes Aufsatz darüber, warum diese Indexberechnung gegenüber einfacheren Methoden bevorzugt wird (zum Beispiel den Modulus).

Ich habe das gerade getestet, es funktioniert süß und benötigt keine Nachschlagetabelle. rand_alnum () erzwingt eine Art von Alphanumerik, aber weil es 62 von möglichen 256 Zeichen auswählt, ist das keine große Sache.

 #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; } 

Ich hoffe, das hilft jemandem.

Getestet auf https://www.codechef.com/ide mit 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

Etwas noch einfacher und einfacher, falls Sie froh sind, dass Ihre Zeichenfolge druckbare Zeichen enthält:

 #include  

Hier ist ein lustiger One-Liner. Braucht ASCII.

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

Zufällige Zeichenfolge, jede Ausführungsdatei = andere Zeichenfolge

  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); 

Beispiel für Qt verwenden 🙂

 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; } 

Achten Sie beim Aufruf der function darauf

 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(); } 

(Angepasst an @Ates Goral ) wird jedes Mal die gleiche Zeichenfolge angezeigt . Benutzen

 srand(time(NULL)); 

vor dem Aufruf der function, obwohl die function rand () immer mit 1 @kjfletch gesetzt wird .

Beispielsweise:

 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'; }