C ++에서 임의의 영숫자 문자열을 어떻게 만듭니 까?

영숫자 문자로 구성된 임의의 문자열을 만들고 싶습니다. 문자열의 길이를 지정할 수 있기를 원합니다.

C ++에서 어떻게해야합니까?

Mehrdad Afshari의 대답 은 트릭을 수행 할 것이지만, 나는이 간단한 작업에 대해서는 너무 장황하다는 것을 알았습니다. 룩업 테이블은 때때로 놀라운 일을 할 수 있습니다.

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

다음은 C ++ 11을 사용한 Ates Goral의 답변에 대한 적응입니다. 여기에 람다를 추가했지만 원칙은 전달하여 문자열에 포함 된 문자를 제어 할 수 있다는 것입니다.

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

다음은 임의 문자열 함수에 람다를 전달하는 예입니다. http://ideone.com/Ya8EKf

C ++ 11을 왜 사용 하시겠습니까?

1. 관심있는 문자 집합에 대해 특정 확률 분포 (또는 분포 조합)를 따르는 문자열을 생성 할 수 있기 때문 입니다.
2. 비 결정적 난수 를 기본적으로 지원하기 때문에
3. 유니 코드를 지원하므로 국제화 된 버전으로 변경할 수 있습니다.

예를 들면 다음과 같습니다.

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

샘플 출력.

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

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

방금 이것을 테스트했는데 스위트 작동하고 조회 테이블이 필요하지 않습니다. rand_alnum () 종류는 영숫자를 강제하지만 가능한 256 자 중 62자를 선택하기 때문에 큰 문제가 아닙니다.

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

오히려 수동 루프보다 적절한 사용을 선호 C ++ 알고리즘 이 경우 std::generate_n와 적절한 난수 발생기 :

auto generate_random_alphanumeric_string(std::size_t len) -> std::string {
    static constexpr auto chars =
        "0123456789"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz";
    thread_local auto rng = random_generator<>();
    auto dist = std::uniform_int_distribution{{}, std::strlen(chars) - 1};
    auto result = std::string(len, '\0');
    std::generate_n(begin(result), len, [&]() { return chars[dist(rng)]; });
    return result;
}

이것은 내가이 문제에 대한 "정식"솔루션이라고 부르는 것과 비슷합니다.

불행히도, 일반 C ++ 난수 생성기 (예 : MT19937)를 정확하게 시드하는 것은 정말 어렵습니다 . 따라서 위 코드는 도우미 함수 템플릿을 사용합니다 random_generator.

template <typename T = std::mt19937>
auto random_generator() -> T {
    auto constexpr seed_bits = sizeof(typename T::result_type) * T::state_size;
    auto constexpr seed_len = seed_bits / std::numeric_limits<std::seed_seq::result_type>::digits;
    auto seed = std::array<std::seed_seq::result_type, seed_len>{};
    auto dev = std::random_device{};
    std::generate_n(begin(seed), seed_len, std::ref(dev));
    auto seed_seq = std::seed_seq(begin(seed), end(seed));
    return T{seed_seq};
}

이것은 복잡하고 비효율적입니다. 운 좋게도 thread_local변수 를 초기화하는 데 사용 되므로 스레드 당 한 번만 호출됩니다.

마지막으로 위의 필수 항목은 다음과 같습니다.

#include <algorithm>
#include <array>
#include <cstring>
#include <functional>
#include <limits>
#include <random>
#include <string>

위의 코드는 클래스 템플릿 인수 공제 를 사용하므로 C ++ 17이 필요합니다. 필요한 템플릿 인수를 추가하여 이전 버전에 맞게 간단하게 조정할 수 있습니다.

나는 이것이 누군가를 돕기를 바랍니다.

C ++ 4.9.2를 사용 하여 https://www.codechef.com/ide 에서 테스트

#include <iostream>
#include <string>
#include <stdlib.h>     /* srand, rand */

using namespace std;

string RandomString(int len)
{
   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()
{
   srand(time(0));
   string random_str = RandomString(100);
   cout << "random_str : " << random_str << endl;
}

Output: random_str : DNAT1LAmbJYO0GvVo4LGqYpNcyK3eZ6t0IN3dYpHtRfwheSYipoZOf04gK7OwFIwXg2BHsSBMB84rceaTTCtBC0uZ8JWPdVxKXBd

여기에 재미있는 원 라이너가 있습니다. ASCII가 필요합니다.

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

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

문자열에 인쇄 가능한 문자가 포함되어 있으면 더 간단하고 더 기본적인 것입니다.

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

임의의 문자열, 모든 실행 파일 = 다른 문자열

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

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

무작위로 다시 편리하게합시다!

나는 멋진 C ++ 11 헤더 전용 솔루션을 구성했습니다. 하나의 헤더 파일을 프로젝트에 쉽게 추가 한 다음 테스트를 추가하거나 다른 목적으로 임의의 문자열을 사용할 수 있습니다.

간단한 설명이지만 링크를 따라 전체 코드를 확인할 수 있습니다. 솔루션의 주요 부분은 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모든 임의의 것을 캡슐화하고 자신의 기능을 쉽게 추가 할 수 있습니다. 를 가지고 나면 Randomer문자열을 생성하는 것이 매우 쉽습니다.

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

아래 개선 제안을 작성하십시오. https://gist.github.com/VjGusev/e6da2cb4d4b0b531c1d009cd1f8904ad

그러나 대답이 아닌 것이 나의 필요로 충분하기 때문에 또 다른 적응입니다. 우선 rand ()를 사용하여 난수를 생성하면 각 실행에서 동일한 출력을 얻습니다. 난수 생성기의 시드는 일종의 난수 여야합니다. C ++ 11을 사용하면 "랜덤"라이브러리를 포함 할 수 있고 random_device 및 mt19937을 사용하여 시드를 초기화 할 수 있습니다. 이 시드는 OS에 의해 제공되며 우리에게 충분할 것입니다 (예 : 시계). 내 경우에는 범위 경계가 [0,25] 포함되도록 할 수 있습니다. 마지막으로 적어도 소문자의 임의의 문자열 만 필요했기 때문에 char 추가를 사용했습니다. 캐릭터 풀로 접근하면 나에게 적합하지 않았습니다.

#include <random>    
void gen_random(char *s, const int len){
    static std::random_device rd;
    static std::mt19937 mt(rd());
    static std::uniform_int_distribution<int> dist(0, 25);
    for (int i = 0; i < len; ++i) {
        s[i] = 'a' + dist(mt);
    }
    s[len] = 0;
}

//C++ Simple Code
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<char> alphanum =
    {'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'
};
string s="";
int len=5;
srand(time(0)); 
for (int i = 0; i <len; i++) {
    int t=alphanum.size()-1;
    int idx=rand()%t;
    s+= alphanum[idx];
}
cout<<s<<" ";
return 0;
}

함수를 호출 할 때주의하십시오

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

( @Ates Goral에 적응 됨 ) 매번 동일한 문자 시퀀스가 ​​생성됩니다. 사용하다

srand(time(NULL));

rand () 함수는 항상 1 @kjfletch로 시드되지만 함수를 호출하기 전에 .

예를 들어 :

void SerialNumberGenerator() {

    srand(time(NULL));
    for (int i = 0; i < 5; i++) {
        cout << gen_random(10) << endl;
    }
}

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

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