web-dev-qa-db-fra.com

Comment créer une chaîne alphanumérique aléatoire en C++?

J'aimerais créer une chaîne aléatoire composée de caractères alphanumériques. Je veux pouvoir spécifier la longueur de la chaîne.

Comment puis-je faire cela en C++?

c++stringrandom
150
jm.

Le answer de Mehrdad Afshari ferait l'affaire, mais je l'ai trouvé un peu trop détaillé pour cette tâche simple. Les tables de consultation peuvent 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;
}
252
Ates Goral

Voici mon adaptation de la réponse d'Ates Goral en utilisant C++ 11. J'ai ajouté le lambda ici, mais le principe est que vous pouvez le transmettre et contrôler ainsi les caractères que 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 d'un lambda à la fonction de chaîne aléatoire: http://ideone.com/Ya8EKf

Pourquoi voudriez-vous utiliser C++ 11? 

  1. Parce que vous pouvez produire des chaînes qui suivent une certaine distribution de probabilité (ou une combinaison de distribution) pour le jeu de caractères qui vous intéresse.
  2. Parce qu'il a un support intégré pour nombres aléatoires non déterministes
  3. Parce qu’il supporte l’unicode, vous pouvez donc changer cela en une version internationalisée.

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.

89
Carl

Ma solution 2p:

#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;
}
26
Galik
 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;
 }
15
Mehrdad Afshari

Je viens de tester cela, cela fonctionne bien et ne nécessite pas de table de recherche. Rand_alnum () supprime les caractères alphanumériques mais, puisqu'il sélectionne 62 caractères sur 256, ce n'est pas grave.

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

J'ai tendance à toujours utiliser les méthodes C++ structurées pour ce type d'initialisation. Notez que fondamentalement, ce n’est pas différent de la solution d’Altan. Pour un programmeur C++, cela exprime simplement un peu mieux l’intention et pourrait être plus facilement transférable à 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';

À propos, lisez l’essai de Julienne sur la raison pour laquelle ce calcul de l’indice est préféré aux méthodes plus simples (comme prendre le module).

8
Konrad Rudolph

J'espère que ça aidera 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

7
D D

Voici un one-liner amusant. Nécessite ASCII.

void gen_random(char *s, int l) {
    for (int c; c=Rand()%62, *s++ = (c+"07="[(c+16)/26])*(l-->0););
}
3
geza
#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;
}
2
Hazey

Exemple d'utilisation 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;
}
1
Vitalja Alex

Chaîne aléatoire, chaque fichier d'exécution = chaîne différente

        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);
1
Nehigienix
#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;
}
1
Oleg

Quelque chose d'encore plus simple et plus fondamental au cas où vous seriez heureux que votre chaîne contienne des 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
}
1
Nobilis
#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;
}
0
ras

Faisons à nouveau pratique au hasard!

J'ai mis au point une solution uniquement en-tête pour Nice C++ 11 . Vous pouvez facilement ajouter un fichier d'en-tête à votre projet, puis ajouter vos tests ou utiliser des chaînes aléatoires à d'autres fins.

C'est une description rapide, mais vous pouvez suivre le lien pour vérifier 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 englobe tous les éléments aléatoires et vous pouvez y ajouter facilement vos propres fonctionnalités. Après 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;
}

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

0
Gusev Slava