Comment puis-je créer un hasard alpha-numérique chaîne de caractères en C++?

J'aimerais créer une chaîne de caractères aléatoires, composé de caractères alpha-numériques. Je veux être capable de spécifier la longueur de la chaîne.

Comment puis-je le faire en C++?

InformationsquelleAutor jm. | 2009-01-13
  1. 270

    Mehrdad Afshari de réponse ferait l'affaire, mais je l'ai trouvé un peu trop verbeux pour cette simple tâche. Les tables de recherche peut parfois faire des merveilles:

    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;
}
    • Nice. Je voulais l'indiquer dans un commentaire. Cette approche fonctionne mieux si, comme dans cet exemple, le nombre d'éléments de est petit. L'inconvénient est qu'il n'a pas d'échelle eh bien, si vous voulais pour générer des nombres aléatoires à partir de grandes distinct continue d'ensembles.
    • J'aime cette réponse mieux. C'est plus souple, parce que vous pouvez éliminer facilement des caractères. Par exemple, faire un hasard chaîne alphanumérique sans personnage, je serait trivial dans cette fonction. Il est aussi plus facile à comprendre, à mon avis.
    • +1, de Cette façon, vous pouvez ajouter certains char spécial sans avoir à vous soucier de tout l'ensemble. Beaucoup mieux.
    • Mehrdad, pourquoi n'est-il pas de l'échelle? un tableau de caractères est un tableau de char, où il est des chiffres ou des lettres. Ce n'est pas la création aléatoire d'entiers ou de flotteurs, mais les caractères.
    • Je l'ai dit il n'a pas d'échelle de "si...". Clairement, c'est une bonne solution pour ces situations.
    • Nous avons eu un peu de barrière de la langue, ici, sur celui-ci. "Ainsi, un ensemble continu est une condition-treillis complet qui est dense total de la commande. Le membre de phrase "continue" n'est pas utilisée dans la littérature Occidentale." à partir de eom.springer.de/c/c025760.htm
    • WolframDragon, désolé, l'anglais n'est pas ma langue maternelle.
    • Votre réponse est une bonne approche, mais vous devez supprimer le "- 1" à partir de votre algorithme. Il est incorrect. Il est facile de voir si vous visualisez une plus petite taille de la matrice, comme 1 ou 2.
    • Merci pour le pointeur. J'ai déjà eu mes doutes lors de l'écriture, mais mes VS a fait des siennes et je n'ai pas pu tester mon code 🙂
    • N'oubliez pas d'appeler la graine du générateur de nombres aléatoires 🙂
    • N'oubliez pas d'utiliser un Haut niveau d'Entropie de la source de semences soit. ( Ie: pas 0 + ID de processus, j'entends une tranche de mémoire non initialisée œuvres de nice )
    • c'est une solution sympa, +1 . mais je pense que vous voulez indexer avec "rand() % (sizeof(numérique) - 1)", parce que la sizeof prend le caractère de fin null en compte
    • ah, je viens de voir que tu avais déjà dans l'origine. eh bien, il avait raison. nous allons voir avec un tableau de taille 2: "1" ('1','\0'). (rand() % sizeof(numérique)) serait de vous donner des indices à partir de 0..1 . mais c'est faux, bien sûr.
    • Je le savais! Je savais que mon intuition était juste la première fois. Revenue à utiliser -1. Merci!
    • c'est ce que l'OpenSSL équipe bien que, jusqu'à ce que quelqu'un a pensé à mettre leur code par valgrind. 😉
    • Vous ne voulez probablement pas à utiliser un simple rand() avec le module. Voir: c-faq.com/lib/randrange.html
    • Un inconvénient de cette approche que je voudrais mentionner est, de longues tables/ficelles de ce genre sont d'une révision du code cauchemar et sont sujettes à des erreurs stupides.
    • Je pense que la ligne s[len] = 0 est incorrect. Si s est une chaîne C (NULL) puis la signature de la méthode n'aura pas le lenparamètre en elle. Imo, si vous êtes de passage à la longueur comme argument, vous êtes en supposant que le tableau n'est pas une chaîne C. Ainsi, si vous n'êtes pas en passant une chaîne C de la fonction, la ligne s[len] = 0 pourrait casser des choses, puisque la matrice de 0 à len-1. Et même si vous passez une chaîne C de la fonction de la ligne s[len] = 0 serait redondante.
    • Ce code pourrait être dangereux, parce que en général, des fonctions avec des paramètres comme "len" comprennent la valeur NULL dans leur compte. Mais cette fonction s'écrit len+1 caractères dans la chaîne de sortie. Donc, vous devez être prudent en l'utilisant, dans la mesure où si vous avez char buffer[16]; vous fait appel gen_random(buffer, sizeof(buffer) - 1); en accordant une attention particulière à se souvenir de la - 1
    • Cela ne fonctionnera pas correctement si vous utilisez des caractères larges (c'est à dire wchar_t). sizeof() ne vous donne pas le nombre d'éléments dans un tableau, il vous donne le nombre d'octets occupés. Ce sera évidemment incorrect lors de l'utilisation de caractères larges. Vous avez besoin de diviser par sizeof(numérique[0]) ou, encore mieux, si vous utilisez Visual Studio utiliser les _countof
    • Pouvons-nous en faire size_t len et size_t i? 🙂
    • Veuillez utiliser le C++11 ou de l'amplification aléatoire, nous sommes en 2016 maintenant
    • Ses un copier coller à partir d'officiel c++, site internet. cplusplus.com/forum/windows/88843
    • Salut. Regardez les dates.
    • des excuses. Je prends mon commentaire à l'arrière.
    • Nous avons besoin d'un moyen de lavabo obsolètes réponses sur stackoverflow.
    • rand() ?!?!?! en 2018 !??!
    • Les réponses peuvent être mis à jour, n'hésitez pas à le faire (mais si vous le faites, assurez-vous que vous mentionnez dans votre modifier le commentaire que vous avez la mise à jour de la réponse pour le C++moderne).

    InformationsquelleAutor Ates Goral
  2. 100

    Voici mon adaptation de l'Ates Goral de la réponse à l'aide de C++11. J'ai ajouté le lambda ici, mais le principe est que vous pourriez passer dans et ainsi contrôler ce que les caractères de votre chaîne contient:

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

    Voici un exemple de passage dans un lambda de la chaîne aléatoire de fonction: http://ideone.com/Ya8EKf

    Pourquoi voudriez-vous utiliser C++11?

    1. Parce que vous pouvez produire des chaînes qui suivent un certain distribution de probabilité (ou à la distribution combinaison) pour le jeu de caractères qui vous intéresse.
    2. Parce qu'il a un support intégré pour non-déterministe nombres aléatoires
    3. Car il prend en charge unicode, donc vous pouvez changer ce une version internationale.

    Par exemple:

    #include <iostream>
#include <vector>
#include <random>
#include <functional> //for std::function
#include <algorithm>  //for std::generate_n
typedef std::vector<char> 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<char(void)> 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<<random_string(length,randchar)<<std::endl;
return 0;
}

    Exemple de sortie.

    • Notez que, sur au moins MSVC 2012, vous aurez besoin de const auto randSeed = std::random_device(), puis passer randSeed à std::default_random_engine(). std::random_device{}() ne peut pas compiler avec cette version.
    • Si vous êtes à l'aide de C++11, n'est-il pas préférable de ne pas utiliser rand() dans votre premier extrait de code?
    • C++11, permet de séparer le générateur du moteur, mais ce qui est le mieux dépend de ce que les besoins de votre application. C'est pourquoi mon premier extrait utilise rand et la seconde ne l'est pas.
    • Je dirais que c'est jamais correct d'utiliser rand() plus. Il n'est même pas uniforme pour pleurer à haute voix...
    • Et je dirais que la distribution des données n'est même pas partie de la question. De plus, la réponse n'est pas à vous donner quelque chose à copier coller dans le code de production. La réponse est simplement pour illustrer les différents points de contrôle, vous pouvez faire de l'exercice durant chaîne aléatoire de la génération.
    • Je pense que dans le C++ de la communauté, rand, est obsolète et est bien connue anti-modèle pour de nombreuses raisons côté de la non-uniformité (voir STL parler "Rand Considérées comme Nuisibles"). L'abstraction de la génératrice de la vue est un général, C++ concept qui, je pense, est important pour les praticiens et les étudiants en C++ pour apprendre (à se demander comment elle transporte plus de std::chrono, std::string_view, etc).

    InformationsquelleAutor Carl
  3. 32

    Mon 2p solution:

    #include <random>
#include <string>
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<std::string::size_type> pick(0, sizeof(chrs) - 2);
std::string s;
s.reserve(length);
while(length--)
s += chrs[pick(rg)];
return s;
}
    • Peut-être que l'utilisation default_random_engine au lieu de mt19937? Le code ressemblerait plus générique.
    • Pour être honnête std::default_random_engine n'est pas quelque chose que je sentir bien à propos de recommander que la norme ne donne aucune garantie quant à sa qualité, l'efficacité ou la répétabilité entre les implémentations.
    • Pour éviter d'utiliser un char littéral de tableau et donc d'avoir à utiliser sizeof, changer la auto& à std::string, qui vous donne std::string::length
    • J'ai senti que l'accès à un std::string était susceptible d'être plus lente, car il contient un pointeur interne de ses données. Que signifierait une indirection supplémentaire qu'un tableau statique n'a pas besoin. Aussi sizeof ne peut jamais être plus lent que std::string::size parce que c'est un moment de la compilation constante.
    InformationsquelleAutor Galik
  4. 15
     void gen_random(char *s, size_t len) {
for (size_t 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;
}
    • Nice: ceci est indépendant du jeu de caractères (au moins pour tous les jeux de caractères qui ont a..z,A..Z, 0..9 continguous).
    • vrai, mais ce que d'autres jeux de caractères sont ceux-là? (EBCDIC n'a pas contigus lettres).
    • La messagerie unifiée. Je suppose que je suis surpris. Je viens de parroting quelque chose d'un professeur m'a dit une fois...
    • Une vérification rapide de la norme montre pas de telles exigences de continuité dans la section 2.2, où je devais attendre d'eux.
    • 0..9 doivent être contiguës, bien que. pas de numéro de section, mais je suis sûr à ce sujet.
    • Ascii feather pas... 0-9 a-z A-Z sont les 3 groupes contigus.

    InformationsquelleAutor Mehrdad Afshari
  5. 9

    Je viens de testé, il fonctionne doux et ne nécessite pas une table de recherche. rand_alnum() tri des forces caractères alphanumériques, mais parce qu'il sélectionne 62 possible de 256 caractères, il n'est pas une grosse affaire.

    #include <cstdlib>   //for rand()
#include <cctype>    //for isalnum()   
#include <algorithm> //for back_inserter
#include <string>
char 
rand_alnum()
{
char c;
while (!std::isalnum(c = static_cast<char>(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;
}
    • Il n'y a aucun moyen de savoir combien de temps cette fonction à exécuter. Il est très peu probable, mais à strictement parler, ce qui pourrait s'exécuter indéfiniment.
    InformationsquelleAutor nly
  6. 8

    J'ai tendance à toujours utiliser les structurée C++ moyens pour ce genre d'initialisation. Remarquez que, fondamentalement, ce n'est pas différent Altan de la solution. Pour un programmeur C++, c'est juste exprime l'intention d'un peu mieux et peut-être plus facilement portable vers d'autres types de données. Dans ce cas, la fonction C++ generate_n exprime exactement ce que vous voulez:

    struct rnd_gen {
rnd_gen(char const* range = "abcdefghijklmnopqrstuvwxyz0123456789")
: range(range), len(std::strlen(range)) { }
char operator ()() const {
return range[static_cast<std::size_t>(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';

    Par le chemin, lire Julienne de l'essai de sur les raisons de cette calcul de l'indice est préféré par rapport à des méthodes plus simples (comme prendre le module).

    InformationsquelleAutor Konrad Rudolph
  7. 8

    J'espère que cela aide quelqu'un.

    Testé à https://www.codechef.com/ide avec C++ 4.9.2

    #include <iostream>
#include <string>
#include <stdlib.h>     /* 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

    • Plus 1, Moins 1: Lecteur, méfiez-vous: RandomString(100)! 😉
    • Ce code est toujours en panne et a plusieurs problèmes. Le plus important std::srand() ne devrait vraiment être appelé une fois au début du programme (de préférence, la première chose main()). Le code, comme c'est, va générer beaucoup de identique "aléatoire" des chaînes si elle est appelée dans une boucle.
    InformationsquelleAutor D D
  8. 4

    Voici un drôle one-liner. Les besoins en ASCII.

    void gen_random(char *s, int l) {
for (int c; c=rand()%62, *s++ = (c+"07="[(c+16)/26])*(l-->0););
}
    InformationsquelleAutor geza
  9. 3
    #include <random>
#include <iostream>
template<size_t N>
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;
}
    InformationsquelleAutor Hazey
  10. 1

    Quelque chose d'encore plus simple et la plus basique dans le cas où vous êtes heureux de votre chaîne pour contenir tous les caractères imprimables:

    #include <time.h>   //we'll use time for the seed
#include <string.h> //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
}
    • Je suppose que c'est la solution la plus simple et absolument approprié pour le cas avec le jeu de caractères spécifié
    InformationsquelleAutor Nobilis
  11. 1

    Chaîne aléatoire, chaque fichier = chaîne de caractère

            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);
    • C'est un comportement indéfini, parce que std::generate_n assumera la custom_string a longueur LENGTH_NAME, mais il ne le fait pas.
    InformationsquelleAutor Nehigienix
  12. 1

    Exemple pour utiliser 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;
}
    • Pouvez-vous revenir sur votre réponse? Afficher seulement un morceau de code est souvent pas très utile.
    InformationsquelleAutor Vitalja Alex
  13. 1
    #include <iostream>
#include <string>
#include <random>
std::string generateRandomId(size_t length = 0)
{
static const std::string allowed_chars {"123456789BCDFGHJKLMNPQRSTVWXZbcdfghjklmnpqrstvwxz"};
static thread_local std::default_random_engine randomEngine(std::random_device{}());
static thread_local std::uniform_int_distribution<int> randomDistribution(0, allowed_chars.size() - 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;
}
    InformationsquelleAutor Oleg
  14. 0
    #include <iostream>
#include <string>
#include <stdlib.h>
int main()
{
int size;
std::cout << "Enter size : ";
std::cin >> size;
std::string str;
for (int i = 0; i < size; i++)
{
auto d = rand() % 26 + 'a';
str.push_back(d);
}
for (int i = 0; i < size; i++)
{
std::cout << str[i] << '\t';
}
return 0;
}
    InformationsquelleAutor ras
  15. 0

    Nous allons faire des pratiques de nouveau!

    J'ai fait une belle C++11 en-tête seule solution.
    Vous pouvez facilement ajouter un fichier d'en-tête à votre projet, puis ajoutez vos tests ou de l'utilisation des chaînes aléatoires à autre.

    C'est une description rapide, mais vous pouvez suivre le lien pour voir le code complet. La partie principale de la solution est dans la classe Randomer:

    class Randomer {
//random seed by default
std::mt19937 gen_;
std::uniform_int_distribution<size_t> dist_;
public:
/* ... some convenience ctors ... */
Randomer(size_t min, size_t max, unsigned int seed = std::random_device{}())
: gen_{seed}, dist_{min, max} {
}
//if you want predictable numbers
void SetSeed(unsigned int seed) {
gen_.seed(seed);
}
size_t operator()() {
return dist_(gen_);
}
};

    Randomer incapsulates tous des trucs aléatoires et vous pouvez ajouter vos propres fonctionnalités facilement. Après nous avoir Randomer, il est très facile de générer des chaînes:

    std::string GenerateString(size_t len) {
std::string str;
auto rand_char = [](){ return alphabet[randomer()]; };
std::generate_n(std::back_inserter(str), len, rand_char);
return str;
}

    Écrire vos suggestions d'amélioration ci-dessous.
    https://gist.github.com/VjGusev/e6da2cb4d4b0b531c1d009cd1f8904ad

    InformationsquelleAutor Gusev Slava
  16. -1

    Être ware lors de l'appel de la fonction 

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

    (adapté de @Ates Goral) il en résulte la même séquence de caractères à chaque fois. Utilisation

    srand(time(NULL));

    avant l'appel de la fonction, bien que la fonction rand() est toujours ensemencés avec 1 @kjfletch.

    Par Exemple:

    void SerialNumberGenerator() {
srand(time(NULL));
for (int i = 0; i < 5; i++) {
cout << gen_random(10) << endl;
}
}
    InformationsquelleAutor Mr.Sheep
  17. -2
    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';
}
    • Regarde à peu près le même que le plus haut classé de réponse. Pas sûr que cette réponse n'ajoute aucune valeur.
    • Oui, il le fait "srand(time(NULL));" L'indice sera aléatoire à chaque itération, ce qui rend votre chaîne plus aléatoire xD La chaîne sera différente à chaque fois qu'il exécute la fonction ... Aussi les personnages dans le Syms représenter un tableau unique, pas de tableau de pointeurs vers des chaînes de caractères.
    • Avez-vous essayé? srand(time(NULL)) réinitialise le générateur aléatoire de même de tout le cycle et donc essentiellement d'impression de ligne de la même symbole.
    • Bon travail là-bas, fixe 🙂
    • Il fonctionne sur mon STM32F4 xD
    InformationsquelleAutor Деян Добромиров