C++ Academy · Aula

Inicialização adequada

Obtenha aleatoriedade reproduzível

Inicialização adequada é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

O que é a inicialização por semente

Uma semente é o estado inicial de um gerador. A mesma semente reproduz a mesma sequência; uma semente diferente produz uma sequência diferente.

#include <iostream>
#include <random>

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

Semente fixa para reprodutibilidade

Uma semente constante torna os resultados repetíveis, o que é ideal para testes e depuração.

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

Dispositivo aleatório padrão

std::random_device fornece sementes não determinísticas a partir do sistema operacional. Use-o uma vez para inicializar o gerador.

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

Inicialize uma vez e reutilize

Inicialize o gerador uma única vez na inicialização do programa. Inicializá-lo novamente antes de cada extração compromete a qualidade da aleatoriedade.

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

O problema da semente baseada no horário

Inicializar com time(nullptr) muda apenas uma vez por segundo, portanto programas iniciados juntos obtêm a mesma sequência. Prefira 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;
}

Inicialização com uma sequência de sementes

Um gerador tem muito estado interno. std::seed_seq distribui vários valores de semente por todo esse estado para obter uma inicialização melhor.

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

Combinando valores do dispositivo aleatório

Para obter uma inicialização de alta qualidade, reúna vários valores de random_device em uma 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;
}

Reinicializando explicitamente

Você pode redefinir um gerador existente com seed(value) para reiniciar a sequência a partir de um ponto conhecido.

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

Salvando e restaurando o estado

Um gerador pode ser enviado para um fluxo e depois recuperado dele, permitindo salvar e retomar um estado aleatório exato.

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

O dispositivo aleatório não é reprodutível

Como random_device é não determinístico, nunca o use quando precisar reproduzir uma execução. Para isso, use uma semente fixa.

#include <iostream>
#include <random>

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

Um gerador reutilizável

Um padrão comum encapsula um gerador inicializado com uma semente em um pequeno auxiliar, para que o restante do código apenas solicite 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;
}

Verificação rápida

Teste sua compreensão da inicialização por sementes.

Recapitulação

Você aprendeu a inicializar corretamente os geradores:

uma semente fixa produz execuções reprodutíveis; std::random_device produz sequências únicas
inicialize uma vez na inicialização do programa, não a cada extração; evite a semente imprecisa baseada em time()
seed_seq distribui a entropia pelo gerador, e o estado do gerador pode ser salvo e restaurado por meio de fluxos

Em seguida, você aplicará tudo isso a exemplos práticos.

Perguntas Frequentes

A aula “Inicialização adequada” é grátis?

Sim — o texto completo de “Inicialização adequada” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Inicialização adequada”?

Obtenha aleatoriedade reproduzível Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Inicialização adequada”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C++ Academy