Implementar um gerador simples
Construa uma corrotina geradora que produza valores de forma preguiçosa
Implementar um gerador simples é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 2 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.
Geradores como corrotinas
Um gerador é uma corrotina que produz valores um de cada vez. Cada chamada ao gerador produz o próximo valor e suspende a execução.
O tipo Generator
Defina uma classe com um promise_type aninhado. O compilador o usa para gerenciar o estado da corrotina.
template <typename T>
struct Generator {
struct promise_type {
T current_value;
Generator get_return_object() {
return Generator{std::coroutine_handle<promise_type>::from_promise(*this)};
}
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_void() {}
std::suspend_always yield_value(T value) {
current_value = value;
return {};
}
void unhandled_exception() { std::terminate(); }
};
std::coroutine_handle<promise_type> h;
// ... constructors, destructor, next() ...
};Usando o gerador
Depois de definidos, os geradores se comportam como o yield do Python.
Generator<int> counting() {
int n = 0;
while (true) co_yield n++;
}
auto g = counting();
for (int i = 0; i < 5; ++i) {
std::cout << g.next() << " ";
}
// 0 1 2 3 4Manipulador de corrotina
O compilador retorna um std::coroutine_handle. Ele representa a corrotina suspensa — o senhor pode usar resume(), destroy() ou verificar done().
Pontos de suspensão
Cada co_yield suspende a execução. Quando o chamador usa resume(), a execução continua até a próxima suspensão ou até o fim da corrotina.
initial_suspend e final_suspend
Dois pontos de personalização:
initial_suspend— retornesuspend_alwayspara uma inicialização preguiçosa;suspend_neverpara uma inicialização imediatafinal_suspend— controla a limpeza. Normalmente, usesuspend_alwayspara uma destruição adequada
std::generator do C++23
O C++23 adicionou std::generator em <generator>. O senhor não precisa mais criar manualmente o tipo para o caso comum.
#include <generator>
std::generator<int> counting() {
int n = 0;
while (true) co_yield n++;
}for baseado em intervalo
Se o tipo do gerador for compatível com begin/end, o for baseado em intervalo funcionará imediatamente.
for (int x : counting()) {
if (x >= 10) break;
std::cout << x;
}Semântica de consulta versus envio
Os geradores são baseados em consulta — o chamador conduz a iteração. As corrotinas baseadas em envio são tarefas assíncronas.
Casos de uso
Os geradores são excelentes para:
- Sequências preguiçosas (Fibonacci, números primos, leitores de arquivos linha a linha)
- Transmitir dados sem materializá-los
- Iterar sobre estruturas semelhantes a árvores
Considerações sobre memória
Por padrão, o quadro da corrotina é alocado na memória dinâmica. O compilador pode eliminar essa alocação quando a expansão em linha permitir — faça medições quando o desempenho for importante.
Bibliotecas para explorar
Para aprender, cppcoro, de Lewis Baker, oferece tipos de gerador e tarefa bem documentados. Boost.Asio fornece E/S compatível com corrotinas. A partir do C++23, a biblioteca padrão também oferece suporte.
Verificação rápida
Qual é o tipo da biblioteca padrão do C++23 para corrotinas geradoras?
Recapitulação
Uma corrotina geradora produz valores de forma preguiçosa com co_yield. Implemente-a com uma classe que contenha um promise_type. O C++23 padronizou std::generator. Os geradores são excelentes para sequências preguiçosas e transmissão de dados.
Perguntas Frequentes
A aula “Implementar um gerador simples” é grátis?
Sim — o texto completo de “Implementar um gerador simples” é 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 “Implementar um gerador simples”?
Construa uma corrotina geradora que produza valores de forma preguiçosa 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 2 de 4.
Quanto tempo leva a aula “Implementar um gerador simples”?
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
- Conceitos de corrotinas: co_await, co_yield, co_return
- Implementar um gerador simples
- Tarefas assíncronas e tipos awaiter
- Alocação de quadros de corrotinas