C++ Academy · Lección

Generadores aleatorios

Genere bits aleatorios

Generadores aleatorios es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

¿Por qué <random>?

El antiguo rand() es de baja calidad y difícil de controlar. La biblioteca <random> separa la aleatoriedad en motores (fuentes de bits aleatorios) y distribuciones (formas de la salida).

#include <iostream>
#include <random>

int main() {
    std::mt19937 engine(42);
    std::cout << "engine produced a value\n";
    unsigned int v = engine();
    std::cout << (v != 0 ? "non-zero" : "zero") << '\n';
    return 0;
}

El Mersenne Twister

std::mt19937 es el motor más habitual: rápido, de alta calidad y con un período largo. El número indica el tamaño de su estado en bits.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(1);
    unsigned int a = gen();
    unsigned int b = gen();
    std::cout << (a != b ? "two different values" : "same") << '\n';
    return 0;
}

Los motores son deterministas

Dada la misma semilla, un motor siempre produce la misma secuencia. Esto permite reproducir los resultados.

#include <iostream>
#include <random>

int main() {
    std::mt19937 a(123), b(123);
    std::cout << std::boolalpha << (a() == b()) << '\n';
    std::cout << (a() == b()) << '\n';
    return 0;
}

Llamar al motor

Un motor se puede invocar. Cada llamada a engine() devuelve el siguiente entero aleatorio sin procesar dentro de su rango.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(7);
    for (int i = 0; i < 3; ++i) {
        unsigned int v = gen();
        std::cout << (v % 100) << ' ';
    }
    std::cout << '\n';
    return 0;
}

Rango del motor

min() y max() indican el rango de valores sin procesar que puede emitir un motor.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen;
    std::cout << "min: " << gen.min() << '\n';
    std::cout << "max: " << gen.max() << '\n';
    return 0;
}

Otros motores

La biblioteca ofrece varios motores:

minstd_rand: generador congruencial lineal pequeño.
mt19937: predeterminado de propósito general.
ranlux48: de mayor calidad y más lento.

#include <iostream>
#include <random>

int main() {
    std::minstd_rand lcg(5);
    std::mt19937 mt(5);
    std::cout << (lcg() % 10) << ' ' << (mt() % 10) << '\n';
    return 0;
}

Motor de 64 bits

Use std::mt19937_64 cuando necesite valores aleatorios de 64 bits, por ejemplo, para hashes grandes o rangos enormes.

#include <iostream>
#include <random>

int main() {
    std::mt19937_64 gen(99);
    unsigned long long v = gen();
    std::cout << "got a 64-bit value: " << (v != 0 ? "yes" : "no") << '\n';
    return 0;
}

Motor frente a distribución

La salida sin procesar del motor es uniforme en un rango enorme. Para obtener valores útiles, como el resultado de tirar un dado, pase el motor a una distribución.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(2024);
    std::uniform_int_distribution<int> die(1, 6);
    std::cout << "rolled " << die(gen) << '\n';
    return 0;
}

Descartar valores

discard(n) avanza el motor n pasos sin producir salida, lo que resulta útil para avanzar en una secuencia.

#include <iostream>
#include <random>

int main() {
    std::mt19937 a(10), b(10);
    b.discard(2);
    a(); a();
    std::cout << std::boolalpha << (a() == b()) << '\n';
    return 0;
}

Reutilizar un motor

Cree un único motor y reutilícelo para toda la aleatoriedad del programa. Crear un motor nuevo cada vez es innecesario y puede reducir la calidad.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(2026);
    std::uniform_int_distribution<int> d10(1, 10);
    int total = 0;
    for (int i = 0; i < 5; ++i) total += d10(gen);
    std::cout << "sum of 5 rolls: " << total << '\n';
    return 0;
}

El problema de la semilla predeterminada

Un motor construido por defecto usa una semilla predeterminada fija, por lo que produce la misma secuencia en cada ejecución. Debe inicializarlo con una semilla para obtener una variación real (esto se explica en la siguiente lección).

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen; // default seed: same every run
    std::cout << "first value mod 1000: " << (gen() % 1000) << '\n';
    return 0;
}

Comprobación rápida

Compruebe su comprensión de los motores aleatorios.

Resumen

Ha aprendido sobre los motores aleatorios:

<random> separa los motores (bits) de las distribuciones (forma)
std::mt19937 es el motor de referencia; es determinista para una semilla dada
reutilice un motor y dele una semilla adecuada para obtener una variación real

A continuación, dará forma a la salida del motor mediante distribuciones.

Preguntas frecuentes

¿La lección «Generadores aleatorios» es gratis?

Sí — el texto completo de «Generadores aleatorios» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Generadores aleatorios»?

Genere bits aleatorios Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Generadores aleatorios»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C++ Academy