std::function
Almacene cualquier objeto invocable
std::function es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 2 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::function?
std::function es un contenedor con borrado de tipos que puede almacenar cualquier objeto invocable que coincida con una firma determinada: funciones libres, lambdas, functors o expresiones vinculadas.
- Se declara con la firma de destino.
- Se encuentra en
<functional>.
#include <iostream>
#include <functional>
int add(int a, int b) { return a + b; }
int main() {
std::function<int(int, int)> f = add;
std::cout << f(2, 3) << '\n';
return 0;
}Almacenar una lambda
A diferencia de un puntero a función sin más, std::function almacena sin problemas una lambda, incluso una que tenga capturas.
#include <iostream>
#include <functional>
int main() {
int offset = 10;
std::function<int(int)> f = [offset](int x) { return x + offset; };
std::cout << f(5) << '\n';
return 0;
}Almacenar un functor
Un functor es un objeto que tiene operator(). std::function puede encapsularlo y llamar a su operador cuando se invoca.
#include <iostream>
#include <functional>
struct Multiplier {
int factor;
int operator()(int x) const { return x * factor; }
};
int main() {
std::function<int(int)> f = Multiplier{3};
std::cout << f(4) << '\n';
return 0;
}Reasignar el destino
Una variable de tipo std::function puede apuntar a distintos objetos invocables a lo largo de su vida útil, lo que resulta útil para intercambiar comportamientos en tiempo de ejecución.
#include <iostream>
#include <functional>
int main() {
std::function<int(int)> f = [](int x) { return x + 1; };
std::cout << f(10) << '\n';
f = [](int x) { return x * x; };
std::cout << f(10) << '\n';
return 0;
}std::function vacío
Un std::function construido por defecto no contiene nada. Al llamarlo se lanza std::bad_function_call, así que debe comprobarlo primero.
#include <iostream>
#include <functional>
int main() {
std::function<void()> f;
if (f) {
f();
} else {
std::cout << "empty\n";
}
return 0;
}Como parámetro
Las funciones pueden recibir un parámetro std::function para aceptar cualquier objeto invocable compatible, lo que hace que las API sean flexibles.
#include <iostream>
#include <functional>
void repeat(int n, const std::function<void(int)>& action) {
for (int i = 0; i < n; ++i) action(i);
}
int main() {
repeat(3, [](int i) { std::cout << "step " << i << '\n'; });
return 0;
}Almacenar callbacks
Un uso habitual consiste en guardar un callback en un miembro de una clase para poder invocarlo más tarde, cuando ocurra un evento.
#include <iostream>
#include <functional>
struct Button {
std::function<void()> onClick;
void click() { if (onClick) onClick(); }
};
int main() {
Button b;
b.onClick = [] { std::cout << "clicked!\n"; };
b.click();
return 0;
}Un vector de objetos invocables
Como comparten un mismo tipo, distintos objetos invocables pueden convivir en un contenedor e invocarse por turnos.
#include <iostream>
#include <functional>
#include <vector>
int inc(int x) { return x + 1; }
int main() {
std::vector<std::function<int(int)>> ops;
ops.push_back(inc);
ops.push_back([](int x) { return x * 2; });
for (auto& op : ops) std::cout << op(10) << ' ';
std::cout << '\n';
return 0;
}El coste del borrado de tipos
std::function puede reservar memoria y añade una llamada indirecta, por lo que es ligeramente más lento que una llamada directa o un objeto invocable basado en plantillas. Úselo cuando necesite un almacenamiento uniforme.
#include <iostream>
#include <functional>
int main() {
std::function<int()> f = [] { return 42; };
int total = 0;
for (int i = 0; i < 5; ++i) total += f();
std::cout << total << '\n';
return 0;
}Devolver un std::function
Una fábrica puede crear y devolver un objeto invocable configurado, lo que permite a quien la llama obtener un comportamiento personalizado.
#include <iostream>
#include <functional>
std::function<int(int)> adder(int n) {
return [n](int x) { return x + n; };
}
int main() {
auto add5 = adder(5);
std::cout << add5(10) << '\n';
return 0;
}Comparación con los punteros a funciones
std::function es más flexible que un puntero a función porque almacena estado, pero esa flexibilidad tiene como coste un poco de rendimiento y posiblemente una reserva de memoria.
#include <iostream>
#include <functional>
int main() {
int base = 7;
std::function<int(int)> stateful = [base](int x) { return x + base; };
std::cout << "Stateful result: " << stateful(3) << '\n';
return 0;
}Comprobación rápida
Compruebe cuánto entiende sobre std::function.
Repaso
Aprendió que std::function:
- encapsula cualquier objeto invocable que coincida con su firma, incluidas lambdas con estado y functors
- puede reasignarse, almacenarse en contenedores y devolverse desde fábricas
- lanza
bad_function_callcuando está vacío - tiene un pequeño coste adicional debido al borrado de tipos
A continuación usará std::bind para rellenar previamente los argumentos de los objetos invocables.
Preguntas frecuentes
¿La lección «std::function» es gratis?
Sí — el texto completo de «std::function» 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::function»?
Almacene cualquier objeto invocable 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 2 de 4.
¿Cuánto tiempo toma la lección «std::function»?
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.