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 lambdas 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 envoltorio con borrado de tipos que puede contener cualquier elemento invocable que coincida con una firma específica: funciones, lambdas u objetos 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 regular
    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 permanecen 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 callbacks como miembros de una clase o implementar el patrón Strategy. Sin embargo, el C++ moderno suele preferir las lambdas en lugar de std::bind por su mejor legibilidad y rendimiento; usa std::bind principalmente cuando necesites reordenar argumentos o trabajar con código heredado.

Desafío

Fácil

Construyamos 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 puedan almacenar, intercambiar y personalizar en tiempo de ejecución, mostrando 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 exponentes no negativos).
Calculator.h: Define una clase Calculator que use std::function para almacenar y ejecutar operaciones dinámicamente.
Tu Calculator debería 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 entradas:
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 vinculada debe aceptar dos argumentos, de los cuales solo se usa el primero como base (el segundo argumento se puede ignorar mediante un marcador de posición).
Después de establecer la operación, llama a calculate() con tus dos números e imprime:
```
Result: [value]
```
Después, 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 vinculadas 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() {
    // Leer entradas
    string operation;
    int num1, num2;
    cin >> operation >> num1 >> num2;
    
    // Crear una instancia de Calculator
    Calculator calc;
    
    // TODO: Configura la calculadora según el nombre de la operación
    // Para "add", "subtract", "multiply": asigna la función correspondiente directamente
    // 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 el intercambio de operaciones
    // Asigna una lambda que devuelve a + b + 100 a la calculadora
    // Llama a calculate() de nuevo e imprime el resultado
    // Formato: "With bonus: [value]"
    
    return 0;
}