C++ Academy · Lección

Inicialización adecuada

Obtenga aleatoriedad reproducible

Inicialización adecuada es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 3 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.

¿Qué es la inicialización con una semilla?

Una semilla es el estado inicial de un motor. La misma semilla reproduce la misma secuencia; una semilla diferente produce otra.

#include <iostream>
#include <random>

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

Semilla fija para la reproducibilidad

Una semilla constante hace que los resultados sean repetibles, lo que resulta ideal para las pruebas y la depuración.

#include <iostream>
#include <random>

int main() {
    auto run = [](unsigned s) {
        std::mt19937 g(s);
        return g() % 1000;
    };
    std::cout << run(42) << ' ' << run(42) << '\n';
    return 0;
}

std::random_device

std::random_device proporciona semillas no deterministas a partir del sistema operativo. Úselo una vez para inicializar el motor.

#include <iostream>
#include <random>

int main() {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<int> d(1, 6);
    std::cout << "a roll: " << d(gen) << '\n';
    return 0;
}

Inicializar una vez y reutilizar

Inicialice el motor una sola vez al arrancar el programa. Reinicializarlo antes de cada extracción deteriora la calidad de la aleatoriedad.

#include <iostream>
#include <random>

int main() {
    std::random_device rd;
    std::mt19937 gen(rd());            // seed once
    std::uniform_int_distribution<int> d(1, 100);
    for (int i = 0; i < 3; ++i) std::cout << d(gen) << ' ';
    std::cout << '\n';
    return 0;
}

El problema de usar la hora como semilla

Inicializar con time(nullptr) solo cambia una vez por segundo, por lo que los programas que se inician al mismo tiempo obtienen la misma secuencia. Prefiera random_device.

#include <iostream>
#include <random>
#include <ctime>

int main() {
    std::mt19937 gen(static_cast<unsigned>(std::time(nullptr)));
    std::cout << "seeded from time (coarse)\n";
    std::cout << (gen() % 100) << '\n';
    return 0;
}

Inicialización con seed_seq

Un motor tiene mucho estado interno. std::seed_seq distribuye varios valores de semilla por todo ese estado para lograr una mejor inicialización.

#include <iostream>
#include <random>

int main() {
    std::seed_seq seq{1, 2, 3, 4};
    std::mt19937 gen(seq);
    std::cout << (gen() % 1000) << '\n';
    return 0;
}

Combinar valores de random_device

Para obtener una inicialización de alta calidad, recopile varios valores de random_device en un seed_seq.

#include <iostream>
#include <random>
#include <array>

int main() {
    std::random_device rd;
    std::array<unsigned, 4> seeds{rd(), rd(), rd(), rd()};
    std::seed_seq seq(seeds.begin(), seeds.end());
    std::mt19937 gen(seq);
    std::cout << "well-seeded engine ready\n";
    std::cout << (gen() % 100) << '\n';
    return 0;
}

Reinicialización explícita

Puede restablecer un motor existente con seed(value) para reiniciar su secuencia desde un punto conocido.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(1);
    unsigned first = gen();
    gen.seed(1);             // restart
    std::cout << std::boolalpha << (gen() == first) << '\n';
    return 0;
}

Guardar y restaurar el estado

Puede enviar un motor a un flujo y volver a cargarlo desde él, lo que permite guardar y reanudar un estado aleatorio exacto.

#include <iostream>
#include <sstream>
#include <random>

int main() {
    std::mt19937 gen(5);
    std::ostringstream save; save << gen;
    unsigned expected = gen();
    std::istringstream load(save.str());
    std::mt19937 restored; load >> restored;
    std::cout << std::boolalpha << (restored() == expected) << '\n';
    return 0;
}

random_device no es reproducible

Como random_device es no determinista, no lo use cuando necesite reproducir una ejecución. Para eso, use una semilla fija.

#include <iostream>
#include <random>

int main() {
    const unsigned FIXED = 2026;
    std::mt19937 gen(FIXED); // reproducible across runs
    std::cout << (gen() % 10000) << '\n';
    return 0;
}

Generador reutilizable

Un patrón habitual consiste en encapsular un motor inicializado con una semilla dentro de un pequeño auxiliar, para que el resto del código solo tenga que solicitar números.

#include <iostream>
#include <random>

int roll(std::mt19937& gen) {
    std::uniform_int_distribution<int> d(1, 6);
    return d(gen);
}

int main() {
    std::mt19937 gen(2026);
    std::cout << roll(gen) << ' ' << roll(gen) << '\n';
    return 0;
}

Comprobación rápida

Compruebe su comprensión de la inicialización con semillas.

Repaso

Ha aprendido a inicializar correctamente los motores:

una semilla fija produce ejecuciones reproducibles; std::random_device produce ejecuciones diferentes
inicialice el motor una vez al arrancar el programa, no antes de cada extracción; evite la semilla poco precisa basada en time()
seed_seq distribuye la entropía por el motor, y el estado del motor se puede guardar y restaurar mediante flujos

A continuación, aplicará todo esto a ejemplos prácticos.

Preguntas frecuentes

¿La lección «Inicialización adecuada» es gratis?

Sí — el texto completo de «Inicialización adecuada» 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 «Inicialización adecuada»?

Obtenga aleatoriedad reproducible 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 3 de 4.

¿Cuánto tiempo toma la lección «Inicialización adecuada»?

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