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.
Desafío
FácilVamos 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 sumasubtract(int a, int b): devuelve la diferencia (a - b)multiply(int a, int b): devuelve el productopower(int base, int exponent, int multiplier): devuelvemultiplier * (base ^ exponent). Usa un bucle sencillo para calcular la potencia (supón que los exponentes no son negativos).
Calculator.h: Define una claseCalculatorque usestd::functionpara 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 actualcalculate(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.- Un miembro privado
main.cpp: Lee tres valores de entrada:- Nombre de la operación:
add,subtract,multiplyosquare - Primer número (entero)
- Segundo número (entero)
Crea una
Calculatory configúrala según el nombre de la operación:- Para
add,subtractymultiply: asigna directamente la función correspondiente a la calculadora - Para
square: usastd::bindpara crear una versión especializada depowerque 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]- Nombre de la operación:
Por ejemplo, con las entradas add, 10 y 5:
Result: 15
With bonus: 115Con las entradas multiply, 7 y 3:
Result: 21
With bonus: 110Con las entradas square, 4 y 0:
Result: 16
With bonus: 104Este 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;
}
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
1Fundamentos de la POO
Archivos externosCompilación y construcción en C++Archivos de cabecera y archivos fuenteEspacios de nombres y ámbitoIntroducción a la POO en C++Clases y objetosEl puntero 'this'Métodos (funciones miembro)Atributos (miembros de datos)Fundamentos de constructores y destructoresRepaso: calculadora sencilla4Propiedades de clase
Miembros de instancia vs. estáticosGetters y settersFunciones miembro constPalabra clave mutableMétodos y variables estáticosFunciones y clases friendRepaso: gestor de cuentas bancarias7Herencia
Herencia básicaNiveles de acceso en la herenciaOrden de llamada de constructores y destructoresSobrescritura de métodosFunciones virtuales y VTableHerencia múltipleHerencia virtualRepaso: jerarquía de empleados2Gestión de memoria
Memoria de pila vs. heapPunteros y referenciasMemoria dinámica (new/delete)Punteros inteligentes en C++RAII en C++Repaso: gestor de arreglos dinámicos5Encapsulación
Especificadores de acceso en C++Especificadores de acceso en profundidadOcultación de informaciónStruct vs. classClases anidadas e internasRepaso: sistema de registros de estudiantes8Polimorfismo
Polimorfismo en compilación y en tiempo de ejecuciónSobrecarga de funcionesRepaso de las funciones virtualesFunciones virtuales purasClases abstractasDiseño de interfaces en C++Conversión dinámica y RTTIRepaso: calculadora de formas11Conceptos avanzados de POO
Composición frente a herenciaMixins mediante CRTPIdiom PimplBorrado de tiposClases enum y tipado fuerteManejo de excepciones en POOJerarquías de excepciones personalizadas14Patrones de diseño, parte 2
Patrón CommandPatrón AdapterPatrón DecoratorPatrón Template MethodPatrón StatePatrón CompositeRAII como patrón3Constructores y destructores
Constructor predeterminadoConstructor con parámetrosConstructor de copiaConstructor de movimientoListas de inicialización del constructorConstructores delegadosAnálisis detallado del destructorRegla de tres / cinco / ceroRepaso: clase String6Sobrecarga de operadores
Introducción a la sobrecarga de operadoresSobrecarga de operadores aritméticosSobrecarga de operadores de comparaciónOperadores de flujoSobrecarga del operador de asignaciónSobrecarga de los operadores [] y ()Operadores de conversión de tipoRepaso: clase Matrix9Plantillas
Plantillas de funcionesPlantillas de clasesEspecialización de plantillasPlantillas variádicasFundamentos de SFINAE y rasgos de tiposRepaso: contenedor genérico12Características modernas de C++
Semántica de movimiento y rvaluesReenvío perfectoExpresiones lambda en profundidadstd::function y std::bindconstexpr y constevalDescomposición estructuradaoptional, variant, anyPractica por tu cuenta: Compilador de C++ online