C++ Academy · Lección

std::bind

Asocie argumentos a objetos invocables

std::bind es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué es std::bind?

std::bind crea un nuevo objeto invocable al fijar algunos argumentos de otro existente. Esto se denomina aplicación parcial.

Se encuentra en <functional>.
Devuelve un objeto invocable cuyo tipo no se especifica.

#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 posición

Los marcadores de posición como std::placeholders::_1 indican los argumentos que se proporcionarán más adelante, cuando se llame al objeto vinculado.

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

Reordenar argumentos

Los marcadores de posición pueden aparecer en cualquier orden, lo que permite intercambiar las posiciones de los argumentos que proporciona quien llama.

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

Vincular varios argumentos

Puede fijar varios argumentos a la vez y dejar otros como marcadores de posición.

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

Almacenar el resultado

El objeto que devuelve std::bind puede almacenarse en un std::function para obtener un tipo concreto y con nombre.

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

Vincular funciones miembro

std::bind puede apuntar a una función miembro pasando el puntero a miembro y un objeto (o marcador de posición) 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;
}

Vincular por valor o por referencia

Los argumentos vinculados se copian de forma predeterminada. Incluya uno en std::ref para vincularlo por referencia y hacer visibles los cambios.

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

Usar objetos invocables vinculados en algoritmos

Un objeto invocable vinculado funciona como predicado u operación en los algoritmos estándar.

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

Anidar bind

Las expresiones bind se pueden componer, aunque pronto resultan difíciles de leer. Cada marcador de posición sigue haciendo referencia a los argumentos de la llamada 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;
}

Ignorar argumentos adicionales

Si la llamada vinculada usa solo algunos marcadores de posición, los argumentos adicionales que se pasen al llamar simplemente se ignoran.

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

Cuándo resulta más clara una lambda

El C++ moderno suele preferir una lambda a std::bind porque es más legible y el compilador la optimiza mejor.

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

Comprobación rápida

Compruebe cuánto entiende sobre los marcadores de posición.

Repaso

Aprendió cómo funciona std::bind:

fija algunos argumentos y usa los marcadores de posición _1, _2 para el resto
puede reordenar argumentos, vincular funciones miembro y usar std::ref
los resultados pueden almacenarse en std::function y usarse en algoritmos
las lambdas suelen ser más claras en el C++ moderno

A continuación comparará las lambdas, bind y los punteros a funciones para elegir la herramienta adecuada.

Preguntas frecuentes

¿La lección «std::bind» es gratis?

Sí — el texto completo de «std::bind» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «std::bind»?

Asocie argumentos a objetos invocables Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «std::bind»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C++ Academy