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.

Si bien las lambdas son potentes, a veces es necesario almacenar objetos invocables con diferentes 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 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 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 fijando algunos argumentos de una función existente. Utilice 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");  // Hello, Alice!
    
    auto swapped = std::bind(greet, _2, _1);
    swapped("Bob", "Hi");  // Hi, Bob!
}

Estas herramientas son especialmente útiles en la POO para almacenar callbacks como miembros de clase o para implementar el patrón Strategy. Sin embargo, el C++ moderno a menudo prefiere las lambdas sobre std::bind para una mejor legibilidad y rendimiento; use std::bind principalmente cuando necesite reordenar argumentos o trabajar con código heredado.

Desafío

Fácil

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

Organizarás tu código en tres archivos:

MathOperations.h: Define una colección de funciones matemáticas independientes que servirán como tu 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 simple para calcular la potencia (asume exponentes no negativos).
Calculator.h: Define una clase Calculator que utiliza std::function para almacenar y ejecutar operaciones de forma dinámica.
Tu Calculadora 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 las cabeceras necesarias (<functional>) y asegúrate de incluir tu cabecera 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 un Calculator y configúralo basándote en el nombre de la operación:
- Para add, subtract, y multiply: asigna la función correspondiente directamente 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 donde solo el primero se usa como base (el segundo argumento puede ignorarse usando un placeholder).
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 una lambda que devuelva a + b + 100 a la calculadora, 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 diferentes tipos invocables (funciones regulares, funciones vinculadas y lambdas), mientras que std::bind te permite adaptar funciones existentes fijando algunos de sus argumentos.

Hoja de referencia

El encabezado <functional> proporciona std::function y std::bind para trabajar con objetos invocables de una manera flexible.

std::function es un envoltorio con borrado de tipos (type-erased) que puede almacenar cualquier invocable que coincida con una firma específica:

#include <functional>

std::function<int(int, int)> operation;

operation = add;                              // Función regular
operation = [](int a, int b) { return a * b; }; // Lambda

std::bind crea un nuevo invocable fijando algunos argumentos de una función existente. Use std::placeholders::_1, _2, etc. para argumentos variables:

#include <functional>

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

using namespace std::placeholders;

auto sayHello = std::bind(greet, "Hello", _1);  // Fijar el primer argumento
sayHello("Alice");  // Hello, Alice!

auto swapped = std::bind(greet, _2, _1);  // Reordenar argumentos
swapped("Bob", "Hi");  // Hi, Bob!

Estas herramientas son útiles para almacenar callbacks como miembros de clase o para implementar sistemas de callbacks flexibles. El C++ moderno a menudo prefiere las lambdas sobre std::bind para una mejor legibilidad.

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: Configurar la calculadora basándose en el nombre de la operación
    // Para "add", "subtract", "multiply": asignar la función correspondiente directamente
    // Para "square": usar std::bind para crear una versión especializada de power
    //   que siempre use el exponente 2 y el multiplicador 1
    //   Hint: Usar std::placeholders::_1 para el argumento 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í - usar std::bind con la función power
    }
    
    // TODO: Llamar a calculate() e imprimir el resultado
    // Formato: "Result: [value]"
    
    // TODO: Demostrar el intercambio de operaciones
    // Asignar una lambda que devuelva a + b + 100 a la calculadora
    // Llamar a calculate() de nuevo e imprimir el resultado
    // Formato: "With bonus: [value]"
    
    return 0;
}