Menu
CoddyTech

std::function y std::bind

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 86 de 104.

Aunque las expresiones lambda son potentes, a veces necesitas almacenar objetos invocables de distintos tipos de manera uniforme o adaptar funciones existentes para que coincidan con una firma requerida. std::function y std::bind del encabezado <functional> resuelven estos problemas.

std::function es un contenedor con borrado de tipo que puede almacenar cualquier objeto invocable que coincida con una firma específica: funciones, lambdas u objetos de función:

#include <iostream>
#include <functional>

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

int main() {
    std::function<int(int, int)> operation;
    
    operation = add;                              // Función normal
    std::cout << operation(3, 4) << "\n";        // 7
    
    operation = [](int a, int b) { return a * b; }; // Lambda
    std::cout << operation(3, 4) << "\n";        // 12
}

std::bind crea un nuevo objeto invocable al fijar algunos argumentos de una función existente. Usa std::placeholders::_1, _2, etc. para marcar los argumentos que siguen siendo variables:

#include <iostream>
#include <functional>

void greet(const std::string& greeting, const std::string& name) {
    std::cout << greeting << ", " << name << "!\n";
}

int main() {
    using namespace std::placeholders;
    
    auto sayHello = std::bind(greet, "Hello", _1);
    sayHello("Alice");  // ¡Hola, Alice!
    
    auto swapped = std::bind(greet, _2, _1);
    swapped("Bob", "Hi");  // ¡Hola, Bob!
}

Estas herramientas son especialmente útiles en la POO para almacenar funciones de retorno de llamada como miembros de una clase o implementar el patrón Strategy. Sin embargo, en el C++ moderno suelen preferirse las expresiones lambda a std::bind por su mayor legibilidad y rendimiento; usa std::bind principalmente cuando necesites reordenar argumentos o trabajar con código heredado.

challenge icon

Desafío

Fácil

Vamos a crear una calculadora configurable que demuestre el poder de std::function y std::bind. Crearás un sistema en el que las operaciones matemáticas se pueden almacenar, intercambiar y personalizar en tiempo de ejecución, lo que muestra cómo estas herramientas permiten gestionar callbacks de forma flexible.

Organizarás tu código en tres archivos:

  • MathOperations.h: Define una colección de funciones matemáticas independientes que servirán como biblioteca de operaciones.

    Crea estas funciones:

    • add(int a, int b): devuelve la suma
    • subtract(int a, int b): devuelve la diferencia (a - b)
    • multiply(int a, int b): devuelve el producto
    • power(int base, int exponent, int multiplier): devuelve multiplier * (base ^ exponent). Usa un bucle sencillo para calcular la potencia (supón que los exponentes no son negativos).
  • Calculator.h: Define una clase Calculator que use std::function para almacenar y ejecutar operaciones dinámicamente.

    Tu Calculator debe tener:

    • Un miembro privado std::function<int(int, int)> para almacenar la operación binaria actual
    • setOperation(std::function<int(int, int)> op): establece la operación actual
    • calculate(int a, int b): ejecuta la operación almacenada y devuelve el resultado

    Incluye los encabezados necesarios (<functional>) y asegúrate de incluir tu encabezado MathOperations.

  • main.cpp: Lee tres valores de entrada:
    1. Nombre de la operación: add, subtract, multiply o square
    2. Primer número (entero)
    3. Segundo número (entero)

    Crea una Calculator y configúrala según el nombre de la operación:

    • Para add, subtract y multiply: asigna directamente la función correspondiente a la calculadora
    • Para square: usa std::bind para crear una versión especializada de power que siempre use el exponente 2 y el multiplicador 1. La función enlazada debe aceptar dos argumentos, donde solo el primero se usa como base (el segundo argumento se puede ignorar usando un marcador de posición).

    Después de establecer la operación, llama a calculate() con tus dos números e imprime:

    Result: [value]

    Luego, demuestra el intercambio de operaciones asignando a la calculadora una lambda que devuelva a + b + 100, ejecutándola con las mismas entradas e imprimiendo:

    With bonus: [value]

Por ejemplo, con las entradas add, 10 y 5:

Result: 15
With bonus: 115

Con las entradas multiply, 7 y 3:

Result: 21
With bonus: 110

Con las entradas square, 4 y 0:

Result: 16
With bonus: 104

Este desafío muestra cómo std::function proporciona una forma uniforme de almacenar distintos tipos invocables (funciones normales, funciones enlazadas y lambdas), mientras que std::bind permite adaptar funciones existentes fijando algunos de sus argumentos.

Pruébalo tú mismo

#include <iostream>
#include <string>
#include <functional>
#include "Calculator.h"

using namespace std;

int main() {
    // Lee las entradas
    string operation;
    int num1, num2;
    cin >> operation >> num1 >> num2;
    
    // Crea una instancia de Calculator
    Calculator calc;
    
    // TODO: Configura la calculadora según el nombre de la operación
    // Para "add", "subtract", "multiply": asigna directamente la función correspondiente
    // Para "square": usa std::bind para crear una versión especializada de power
    //   que siempre usa el exponente 2 y el multiplicador 1
    //   Pista: Usa std::placeholders::_1 para el argumento de la base
    
    if (operation == "add") {
        // Tu código aquí
    } else if (operation == "subtract") {
        // Tu código aquí
    } else if (operation == "multiply") {
        // Tu código aquí
    } else if (operation == "square") {
        // Tu código aquí - usa std::bind con la función power
    }
    
    // TODO: Llama a calculate() e imprime el resultado
    // Formato: "Result: [value]"
    
    // TODO: Demuestra cómo cambiar de operación
    // Asigna a la calculadora una lambda que devuelva a + b + 100
    // Llama de nuevo a calculate() e imprime el resultado
    // Formato: "With bonus: [value]"
    
    return 0;
}
quiz iconPonte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Todas las lecciones de Programación Orientada a Objetos

Practica por tu cuenta: Compilador de C++ online