C++ Academy · Aula

std::function

Armazene qualquer objeto chamável

std::function é 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.

O que é std::function?

std::function é um invólucro com apagamento de tipo que pode conter qualquer objeto chamável compatível com uma determinada assinatura: funções livres, lambdas, funtores ou expressões vinculadas.

É declarado com a assinatura desejada.
Está em <functional>.

#include <iostream>
#include <functional>

int add(int a, int b) { return a + b; }

int main() {
    std::function<int(int, int)> f = add;
    std::cout << f(2, 3) << '\n';
    return 0;
}

Armazenando uma lambda

Ao contrário de um ponteiro de função bruto, std::function armazena tranquilamente uma lambda, inclusive uma que tenha capturas.

#include <iostream>
#include <functional>

int main() {
    int offset = 10;
    std::function<int(int)> f = [offset](int x) { return x + offset; };
    std::cout << f(5) << '\n';
    return 0;
}

Armazenando um functor

Um functor é um objeto com operator(). std::function pode encapsulá-lo, chamando o seu operador quando for invocado.

#include <iostream>
#include <functional>

struct Multiplier {
    int factor;
    int operator()(int x) const { return x * factor; }
};

int main() {
    std::function<int(int)> f = Multiplier{3};
    std::cout << f(4) << '\n';
    return 0;
}

Reatribuindo o alvo

Uma variável std::function pode apontar para diferentes objetos chamáveis durante o seu tempo de vida, o que é útil para trocar o comportamento em tempo de execução.

#include <iostream>
#include <functional>

int main() {
    std::function<int(int)> f = [](int x) { return x + 1; };
    std::cout << f(10) << '\n';
    f = [](int x) { return x * x; };
    std::cout << f(10) << '\n';
    return 0;
}

std::function vazio

Um std::function construído com o construtor padrão não contém nada. Chamá-lo lança std::bad_function_call, portanto teste-o primeiro.

#include <iostream>
#include <functional>

int main() {
    std::function<void()> f;
    if (f) {
        f();
    } else {
        std::cout << "empty\n";
    }
    return 0;
}

Como parâmetro

As funções podem receber um parâmetro std::function para aceitar qualquer objeto chamável compatível, tornando as interfaces flexíveis.

#include <iostream>
#include <functional>

void repeat(int n, const std::function<void(int)>& action) {
    for (int i = 0; i < n; ++i) action(i);
}

int main() {
    repeat(3, [](int i) { std::cout << "step " << i << '\n'; });
    return 0;
}

Armazenando funções de retorno

Um uso comum é manter uma função de retorno em um membro de uma classe para que ela possa ser invocada mais tarde, quando ocorrer um evento.

#include <iostream>
#include <functional>

struct Button {
    std::function<void()> onClick;
    void click() { if (onClick) onClick(); }
};

int main() {
    Button b;
    b.onClick = [] { std::cout << "clicked!\n"; };
    b.click();
    return 0;
}

Um vetor de objetos chamáveis

Como compartilham um tipo, diferentes objetos chamáveis podem ficar juntos em um contêiner e ser invocados um após o outro.

#include <iostream>
#include <functional>
#include <vector>

int inc(int x) { return x + 1; }

int main() {
    std::vector<std::function<int(int)>> ops;
    ops.push_back(inc);
    ops.push_back([](int x) { return x * 2; });
    for (auto& op : ops) std::cout << op(10) << ' ';
    std::cout << '\n';
    return 0;
}

O custo do apagamento de tipo

std::function pode alocar memória e adiciona uma chamada indireta, portanto é ligeiramente mais lento do que uma chamada direta ou um objeto chamável baseado em modelo. Use-o quando precisar de armazenamento uniforme.

#include <iostream>
#include <functional>

int main() {
    std::function<int()> f = [] { return 42; };
    int total = 0;
    for (int i = 0; i < 5; ++i) total += f();
    std::cout << total << '\n';
    return 0;
}

Retornando um std::function

Uma fábrica pode criar e retornar um objeto chamável configurado, permitindo que os chamadores obtenham um comportamento personalizado.

#include <iostream>
#include <functional>

std::function<int(int)> adder(int n) {
    return [n](int x) { return x + n; };
}

int main() {
    auto add5 = adder(5);
    std::cout << add5(10) << '\n';
    return 0;
}

Comparando com ponteiros de função

std::function é mais flexível do que um ponteiro de função porque armazena estado, mas essa flexibilidade custa um pouco de desempenho e possivelmente uma alocação.

#include <iostream>
#include <functional>

int main() {
    int base = 7;
    std::function<int(int)> stateful = [base](int x) { return x + base; };
    std::cout << "Stateful result: " << stateful(3) << '\n';
    return 0;
}

Verificação rápida

Teste a sua compreensão sobre std::function.

Recapitulação

Você aprendeu que std::function:

encapsula qualquer objeto chamável compatível com a sua assinatura, incluindo lambdas e funtores com estado
pode ser reatribuído, armazenado em contêineres e retornado por fábricas
lança bad_function_call quando está vazio
tem uma pequena sobrecarga causada pelo apagamento de tipo

Em seguida, você usará std::bind para preencher previamente os argumentos de objetos chamáveis.

Perguntas Frequentes

A aula “std::function” é grátis?

Sim — o texto completo de “std::function” é 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”?

Armazene qualquer objeto chamá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 2 de 4.

Quanto tempo leva a aula “std::function”?

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