C++ Random | "난수 생성" 가이드
이 글의 핵심
C++ Random에 대한 실전 가이드입니다.
Random이란?
C++11 <random> 라이브러리는 고품질 난수 생성을 위한 표준 라이브러리입니다. C 스타일 rand()보다 더 강력하고 유연합니다.
#include <random>
std::random_device rd;
std::mt19937 gen{rd()};
std::uniform_int_distribution<> dist{1, 6};
int dice = dist(gen); // 1~6왜 필요한가?:
- 품질: 균등 분포 보장
- 유연성: 다양한 분포 지원
- 재현성: 시드로 결과 재현
- 타입 안전: 템플릿 기반
// ❌ rand(): 비균등, 예측 가능
int r = rand() % 100; // 0~99 (비균등)
// ✅ C++11 random: 균등, 고품질
std::mt19937 gen{std::random_device{}()};
std::uniform_int_distribution<> dist{0, 99};
int r = dist(gen); // 0~99 (균등)Random 구조:
flowchart LR
A[random_device] -->|시드| B[엔진 mt19937]
B -->|난수| C[분포 uniform_int_distribution]
C -->|최종 난수| D[결과]
3단계 구조:
| 단계 | 역할 | 예시 |
|---|---|---|
| 1. 시드 | 초기값 생성 | std::random_device rd; |
| 2. 엔진 | 난수 생성 | std::mt19937 gen{rd()}; |
| 3. 분포 | 범위 조정 | std::uniform_int_distribution<> dist{0, 99}; |
// 1. 시드: 하드웨어 엔트로피
std::random_device rd;
// 2. 엔진: 메르센 트위스터
std::mt19937 gen{rd()};
// 3. 분포: 0~99 균등 분포
std::uniform_int_distribution<> dist{0, 99};
// 4. 생성
int random = dist(gen);기본 구조
#include <random>
// 1. 시드
std::random_device rd;
// 2. 엔진
std::mt19937 gen{rd()};
// 3. 분포
std::uniform_int_distribution<> dist{0, 99};
// 4. 생성
int random = dist(gen);실전 예시
예시 1: 주사위
#include <random>
class Dice {
std::mt19937 gen;
std::uniform_int_distribution<> dist;
public:
Dice() : gen{std::random_device{}()}, dist{1, 6} {}
int roll() {
return dist(gen);
}
};
int main() {
Dice dice;
for (int i = 0; i < 10; ++i) {
std::cout << dice.roll() << " ";
}
}예시 2: 범위 난수
#include <random>
int randomInt(int min, int max) {
static std::random_device rd;
static std::mt19937 gen{rd()};
std::uniform_int_distribution<> dist{min, max};
return dist(gen);
}
double randomDouble(double min, double max) {
static std::random_device rd;
static std::mt19937 gen{rd()};
std::uniform_real_distribution<> dist{min, max};
return dist(gen);
}
int main() {
std::cout << randomInt(1, 100) << std::endl;
std::cout << randomDouble(0.0, 1.0) << std::endl;
}예시 3: 셔플
#include <random>
#include <algorithm>
#include <vector>
int main() {
std::vector<int> cards = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::random_device rd;
std::mt19937 gen{rd()};
std::shuffle(cards.begin(), cards.end(), gen);
for (int card : cards) {
std::cout << card << " ";
}
}예시 4: 가중치 선택
#include <random>
#include <vector>
int main() {
std::vector<int> items = {1, 2, 3, 4, 5};
std::vector<double> weights = {0.1, 0.2, 0.3, 0.2, 0.2};
std::random_device rd;
std::mt19937 gen{rd()};
std::discrete_distribution<> dist{weights.begin(), weights.end()};
// 가중치에 따라 선택
for (int i = 0; i < 10; ++i) {
int index = dist(gen);
std::cout << items[index] << " ";
}
}난수 엔진
// mt19937: 메르센 트위스터 (권장)
std::mt19937 gen;
// mt19937_64: 64비트
std::mt19937_64 gen64;
// default_random_engine
std::default_random_engine gen_default;
// minstd_rand: 선형 합동
std::minstd_rand gen_lcg;자주 발생하는 문제
문제 1: 시드
// ❌ 고정 시드
std::mt19937 gen{42}; // 항상 같은 난수
// ✅ random_device
std::random_device rd;
std::mt19937 gen{rd()};
// ✅ 시간 기반 (비권장)
std::mt19937 gen{static_cast<unsigned>(std::time(nullptr))};문제 2: 전역 상태
// ❌ 매번 생성
int random() {
std::random_device rd;
std::mt19937 gen{rd()}; // 느림
std::uniform_int_distribution<> dist{0, 99};
return dist(gen);
}
// ✅ static
int random() {
static std::random_device rd;
static std::mt19937 gen{rd()};
static std::uniform_int_distribution<> dist{0, 99};
return dist(gen);
}문제 3: 분포 재사용
std::mt19937 gen{std::random_device{}()};
// ❌ 분포 재생성
for (int i = 0; i < 100; ++i) {
std::uniform_int_distribution<> dist{0, 99};
int r = dist(gen);
}
// ✅ 분포 재사용
std::uniform_int_distribution<> dist{0, 99};
for (int i = 0; i < 100; ++i) {
int r = dist(gen);
}문제 4: rand() 사용
// ❌ rand() (C 스타일, 비권장)
int r = rand() % 100; // 균등하지 않음
// ✅ C++11 random
std::mt19937 gen{std::random_device{}()};
std::uniform_int_distribution<> dist{0, 99};
int r = dist(gen);분포 종류
// 정수
std::uniform_int_distribution<> uniform{0, 99};
std::binomial_distribution<> binomial{10, 0.5};
std::poisson_distribution<> poisson{4.0};
// 실수
std::uniform_real_distribution<> uniformReal{0.0, 1.0};
std::normal_distribution<> normal{0.0, 1.0};
std::exponential_distribution<> exponential{1.0};
// 불리언
std::bernoulli_distribution bernoulli{0.7};실무 패턴
패턴 1: 게임 난수
class GameRandom {
std::mt19937 gen_;
public:
GameRandom() : gen_{std::random_device{}()} {}
// 주사위
int rollDice(int sides = 6) {
std::uniform_int_distribution<> dist{1, sides};
return dist(gen_);
}
// 확률 (0.0 ~ 1.0)
double chance() {
std::uniform_real_distribution<> dist{0.0, 1.0};
return dist(gen_);
}
// 크리티컬 히트 (20% 확률)
bool criticalHit() {
std::bernoulli_distribution dist{0.2};
return dist(gen_);
}
};
// 사용
GameRandom rng;
int damage = rng.rollDice(20); // 1d20
if (rng.criticalHit()) {
damage *= 2;
}패턴 2: 샘플링
#include <random>
#include <vector>
#include <algorithm>
template<typename T>
std::vector<T> randomSample(const std::vector<T>& data, size_t n) {
if (n >= data.size()) {
return data;
}
std::vector<T> result = data;
std::random_device rd;
std::mt19937 gen{rd()};
std::shuffle(result.begin(), result.end(), gen);
result.resize(n);
return result;
}
// 사용
std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto sample = randomSample(data, 3); // 3개 무작위 선택패턴 3: 시뮬레이션
#include <random>
class Simulation {
std::mt19937 gen_;
std::normal_distribution<> normal_;
std::exponential_distribution<> exponential_;
public:
Simulation(unsigned seed = std::random_device{}())
: gen_{seed},
normal_{0.0, 1.0}, // 평균 0, 표준편차 1
exponential_{1.0} {} // 람다 1
// 정규 분포 (키, 몸무게 등)
double normalValue() {
return normal_(gen_);
}
// 지수 분포 (대기 시간 등)
double exponentialValue() {
return exponential_(gen_);
}
};
// 사용
Simulation sim;
double height = 170.0 + sim.normalValue() * 10.0; // 평균 170cm
double waitTime = sim.exponentialValue(); // 평균 1초FAQ
Q1: Random은 무엇인가요?
A: C++11 난수 생성 라이브러리입니다. 고품질 난수를 생성하며, 다양한 분포를 지원합니다.
#include <random>
std::mt19937 gen{std::random_device{}()};
std::uniform_int_distribution<> dist{0, 99};
int r = dist(gen);Q2: 구조는?
A: 시드 + 엔진 + 분포 3단계 구조입니다.
std::random_device rd; // 1. 시드
std::mt19937 gen{rd()}; // 2. 엔진
std::uniform_int_distribution<> dist; // 3. 분포
int r = dist(gen); // 4. 생성Q3: 어떤 엔진을 사용해야 하나요?
A: std::mt19937 (메르센 트위스터) 를 권장합니다.
std::mt19937 gen{std::random_device{}()}; // 32비트
std::mt19937_64 gen64{std::random_device{}()}; // 64비트Q4: rand()를 사용하면 안되나요?
A: 비권장합니다. rand()는 비균등 분포, 낮은 품질, 전역 상태 문제가 있습니다.
// ❌ rand(): 비균등
int r = rand() % 100;
// ✅ C++11 random: 균등
std::uniform_int_distribution<> dist{0, 99};
int r = dist(gen);Q5: 시드는 어떻게 설정하나요?
A: std::random_device 를 권장합니다.
// ✅ random_device: 하드웨어 엔트로피
std::random_device rd;
std::mt19937 gen{rd()};
// ❌ 시간 기반: 예측 가능
std::mt19937 gen{static_cast<unsigned>(std::time(nullptr))};Q6: 재현 가능한 난수를 생성하려면?
A: 고정 시드를 사용합니다.
// 재현 가능
std::mt19937 gen{42}; // 항상 같은 난수
// 테스트에 유용
void testRandom() {
std::mt19937 gen{12345};
// 항상 같은 결과
}Q7: 스레드 안전한가요?
A: 스레드 안전하지 않습니다. 각 스레드마다 별도의 엔진을 사용해야 합니다.
// ❌ 전역 엔진: 경쟁 조건
std::mt19937 globalGen;
void threadFunc() {
int r = std::uniform_int_distribution<>{0, 99}(globalGen); // 위험
}
// ✅ thread_local
thread_local std::mt19937 gen{std::random_device{}()};
void threadFunc() {
int r = std::uniform_int_distribution<>{0, 99}(gen); // 안전
}Q8: Random 학습 리소스는?
A:
- “C++ Primer” by Stanley Lippman
- “Effective Modern C++” by Scott Meyers
- cppreference.com - Random
관련 글: random_device, mt19937, distribution.
한 줄 요약: C++11 random은 고품질 난수 생성을 위한 표준 라이브러리입니다.
같이 보면 좋은 글 (내부 링크)
이 주제와 연결되는 다른 글입니다.
- C++ Distribution | “확률 분포” 가이드
- C++ 난수 생성 | “random” 라이브러리 가이드
- C++ random_device | “하드웨어 난수” 가이드
관련 글
- C++ Distribution |
- C++ random_device |
- C++ 난수 생성 |
- C++ async & launch |
- C++ Atomic Operations |