C++ Academy · Aula

std::bind

Associe argumentos a objetos chamáveis

std::bind é 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 é std::bind?

std::bind cria um novo objeto chamável ao fixar alguns argumentos de um objeto existente. Isso é chamado de aplicação parcial.

Está em <functional>.
Retorna um objeto chamável de tipo não especificado.

#include <iostream>
#include <functional>

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

int main() {
    auto add10 = std::bind(add, 10, 5);
    std::cout << add10() << '\n';
    return 0;
}

Marcadores de posição

Marcadores de posição, como std::placeholders::_1, indicam os argumentos que serão fornecidos mais tarde, quando o objeto vinculado for chamado.

#include <iostream>
#include <functional>

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

int main() {
    using namespace std::placeholders;
    auto add10 = std::bind(add, 10, _1);
    std::cout << add10(7) << '\n';
    return 0;
}

Reordenando argumentos

Os marcadores de posição podem aparecer em qualquer ordem, permitindo trocar as posições dos argumentos fornecidos pelo chamador.

#include <iostream>
#include <functional>

int sub(int a, int b) { return a - b; }

int main() {
    using namespace std::placeholders;
    auto flipped = std::bind(sub, _2, _1);
    std::cout << flipped(3, 10) << '\n';
    return 0;
}

Vinculando vários argumentos

Você pode fixar vários argumentos de uma só vez e deixar os demais como marcadores de posição.

#include <iostream>
#include <functional>

int volume(int l, int w, int h) { return l * w * h; }

int main() {
    using namespace std::placeholders;
    auto box = std::bind(volume, 2, _1, 5);
    std::cout << box(3) << '\n';
    return 0;
}

Armazenando o resultado

O objeto retornado por std::bind pode ser armazenado em um std::function para obter um tipo concreto e nomeado.

#include <iostream>
#include <functional>

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

int main() {
    using namespace std::placeholders;
    std::function<int(int)> add100 = std::bind(add, 100, _1);
    std::cout << add100(1) << '\n';
    return 0;
}

Vinculando funções membro

std::bind pode apontar para uma função membro ao receber o ponteiro para o membro e um objeto (ou marcador de posição) para this.

#include <iostream>
#include <functional>

struct Counter {
    int add(int x) { return value += x; }
    int value = 0;
};

int main() {
    using namespace std::placeholders;
    Counter c;
    auto bump = std::bind(&Counter::add, &c, _1);
    std::cout << bump(5) << ' ' << bump(3) << '\n';
    return 0;
}

Vinculação por valor versus referência

Os argumentos vinculados são copiados por padrão. Envolva um deles em std::ref para vinculá-lo por referência e tornar as alterações visíveis.

#include <iostream>
#include <functional>

void addTo(int& target, int amount) { target += amount; }

int main() {
    using namespace std::placeholders;
    int total = 0;
    auto acc = std::bind(addTo, std::ref(total), _1);
    acc(5);
    acc(10);
    std::cout << total << '\n';
    return 0;
}

Usando objetos chamáveis vinculados em algoritmos

Um objeto chamável vinculado funciona como um predicado ou uma operação em algoritmos padrão.

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

bool greaterThan(int x, int limit) { return x > limit; }

int main() {
    using namespace std::placeholders;
    std::vector<int> v = {1, 5, 8, 2, 9};
    auto over4 = std::bind(greaterThan, _1, 4);
    std::cout << std::count_if(v.begin(), v.end(), over4) << '\n';
    return 0;
}

Aninhando bind

Expressões de bind podem ser compostas, embora isso rapidamente se torne difícil de ler. Cada marcador de posição ainda se refere aos argumentos do chamador final.

#include <iostream>
#include <functional>

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

int main() {
    using namespace std::placeholders;
    auto f = std::bind(add, std::bind(times, 2, _1), 3);
    std::cout << f(5) << '\n';
    return 0;
}

Ignorando argumentos extras

Se a chamada vinculada usar apenas alguns marcadores de posição, quaisquer argumentos extras passados no momento da chamada serão simplesmente ignorados.

#include <iostream>
#include <functional>

int show(int a) { return a; }

int main() {
    using namespace std::placeholders;
    auto f = std::bind(show, _1);
    std::cout << f(42, 99, 100) << '\n';
    return 0;
}

Quando uma lambda é mais clara

O C++ moderno geralmente prefere uma lambda a std::bind porque ela é mais legível e o compilador a otimiza melhor.

#include <iostream>
#include <functional>

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

int main() {
    auto add10 = [](int x) { return add(10, x); };
    std::cout << add10(5) << '\n';
    return 0;
}

Verificação rápida

Teste a sua compreensão sobre marcadores de posição.

Recapitulação

Você aprendeu como std::bind funciona:

fixa alguns argumentos e usa os marcadores de posição _1, _2 para os demais
pode reordenar argumentos, vincular funções membro e usar std::ref
os resultados podem ser armazenados em std::function e usados em algoritmos
lambdas geralmente são mais claras no C++ moderno

Em seguida, você comparará lambdas, bind e ponteiros de função para escolher a ferramenta adequada.

Perguntas Frequentes

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

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

Associe argumentos a objetos chamáveis 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 “std::bind”?

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