std::function: objetos chamáveis com apagamento de tipo
Apague tipos por trás de std::function e compreenda a otimização de pequenos buffers
std::function: objetos chamáveis com apagamento de tipo é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 4 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 problema: um tipo para várias entidades chamáveis
Cada lambda tem um tipo exclusivo. Cada ponteiro de função é um tipo diferente. Precisamos de um tipo que possa armazenar qualquer uma delas — std::function.
Parâmetro de modelo
std::function<Signature> recebe o tipo de retorno e os tipos dos parâmetros. Ele aceita qualquer entidade chamável com essa assinatura.
#include <functional>
std::function<int(int, int)> op;
op = [](int a, int b) { return a + b; };
std::cout << op(3, 4); // 7Armazenando entidades chamáveis diferentes
A mesma variável std::function pode armazenar uma lambda, um ponteiro de função ou um funtor — desde que a assinatura corresponda.
std::function<int(int)> f;
f = [](int x) { return x * 2; }; // lambda
f = ::abs; // function pointer
f = std::negate<int>{}; // functorApagamento de tipo
Internamente, std::function usa apagamento de tipo — armazena qualquer entidade chamável e oculta seu tipo real por trás de uma interface uniforme. Frequentemente, isso é implementado com uma pequena alocação na memória dinâmica.
Custo de desempenho
Chamar por meio de std::function envolve uma chamada indireta, semelhante a uma função virtual. É mais lento que uma chamada direta de lambda. Evite-o em caminhos críticos.
Quando usar std::function
Use-o quando:
- Armazenar funções de retorno de chamada em um contêiner ou membro de uma classe
- Retornar uma entidade chamável de uma função
- Construir um plug-in ou sistema de eventos
std::function vazia
Uma std::function construída por padrão está vazia. Chamá-la lança std::bad_function_call.
std::function<void()> f;
if (f) f(); else std::cout << "no callback set";Ponteiros para funções-membro
Vincule uma função-membro com std::bind ou envolva-a em uma lambda.
struct Obj { void greet(int) {} };
Obj o;
std::function<void(int)> cb = [&](int n) { o.greet(n); };Comparação com ponteiros de função
Ponteiros de função não podem armazenar estado. std::function pode — ao custo de chamadas indiretas.
Comparação com modelos
Modelos com parâmetros chamáveis são especializados em tempo de compilação — são mais rápidos. std::function resolve em tempo de execução — é mais lento, mas flexível.
template <typename F>
void run(F f) { f(); } // compile-time, no overhead
void run(std::function<void()> f) { f(); } // runtime, type erasurestd::function no C++23: std::function_ref
O C++23 adicionou std::function_ref — uma visualização sem posse de uma entidade chamável. Ela evita a alocação na memória dinâmica quando o tempo de vida é limitado.
Alternativas
Existem alternativas leves: std::move_only_function (C++23), tl::function_ref e folly::Function. Escolha com base nas suas necessidades.
Verificação rápida
Qual é a principal desvantagem de std::function?
Recapitulação
std::function<Signature> armazena qualquer entidade chamável com uma assinatura correspondente. É útil para funções de retorno de chamada, plug-ins e polimorfismo em tempo de execução entre entidades chamáveis — ao custo de chamadas indiretas.
Perguntas Frequentes
A aula “std::function: objetos chamáveis com apagamento de tipo” é grátis?
Sim — o texto completo de “std::function: objetos chamáveis com apagamento de tipo” é 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 “std::function: objetos chamáveis com apagamento de tipo”?
Apague tipos por trás de std::function e compreenda a otimização de pequenos buffers 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 4 de 4.
Quanto tempo leva a aula “std::function: objetos chamáveis com apagamento de tipo”?
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
- Objetos de função e funtores
- Capturas de lambdas por valor, por referência e mutable
- Lambdas genéricas e encerramentos no C++14
- std::function: objetos chamáveis com apagamento de tipo