C++ Academy · Lezione

Inizializzazione corretta

Ottenere casualità riproducibile

Lezione 3 di 413 passaggi

Inizializzazione corretta è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

Che cos'è il seeding

Un seed è lo stato iniziale di un motore. Lo stesso seed riproduce la stessa sequenza; un seed diverso ne produce una diversa.

#include <iostream>
#include <random>

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

Seed fisso per la riproducibilità

Un seed costante rende i risultati riproducibili, caratteristica ideale per i test e il debugging.

#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 fornisce seed non deterministici ottenuti dal sistema operativo. Lo utilizzi una sola volta per inizializzare il motore.

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

Inizializzare una volta, riutilizzare

Inizializzi il motore una sola volta all'avvio. Reinizializzarlo prima di ogni estrazione compromette la qualità della casualità.

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

L'insidia del seed basato sull'ora

Inizializzare il motore con time(nullptr) cambia il seed solo una volta al secondo, quindi i programmi avviati contemporaneamente ottengono la stessa sequenza. Preferisca 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;
}

Inizializzazione con seed_seq

Un motore ha una grande quantità di stato interno. std::seed_seq distribuisce diversi valori di seed in tutto lo stato per ottenere un'inizializzazione migliore.

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

Combinazione dei valori di random_device

Per un'inizializzazione di alta qualità, raccolga diversi valori da random_device in 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;
}

Reinizializzazione esplicita

È possibile reimpostare un motore esistente con seed(value) per riavviare la sequenza da un punto noto.

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

Salvataggio e ripristino dello stato

È possibile scrivere lo stato di un motore in uno stream e rileggerlo, così da salvare e riprendere uno stato casuale esatto.

#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 non è riproducibile

Poiché random_device è non deterministico, non lo utilizzi mai quando deve riprodurre un'esecuzione. In quel caso utilizzi un seed fisso.

#include <iostream>
#include <random>

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

Un generatore riutilizzabile

Un modello comune consiste nel racchiudere un motore inizializzato con un seed in un piccolo helper, così il resto del codice deve solo richiedere i numeri.

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

Verifica rapida

Verifichi la Sua comprensione dell'inizializzazione tramite seed.

Rispondi nella lezione interattiva

Riepilogo

Ha imparato a inizializzare correttamente i motori:

un seed fisso rende le esecuzioni riproducibili; std::random_device produce sequenze diverse
inizializzi il motore una volta all'avvio, non a ogni estrazione; eviti il seed basato sul valore poco preciso di time()
seed_seq distribuisce l'entropia nel motore e lo stato del motore può essere salvato e ripristinato tramite stream

Ora applicherà tutto questo ad alcuni esempi pratici.

Gratis per iniziare

Impara C++ con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 51
Lezioni: 203

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Inizializzazione corretta» è gratuita?

Sì — il testo completo di «Inizializzazione corretta» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Inizializzazione corretta»?

Ottenere casualità riproducibile Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Inizializzazione corretta»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C++ Academy