std::function: objetos invocables con borrado de tipos
Oculte los tipos tras std::function y comprenda la optimización de búfer pequeño.
std::function: objetos invocables con borrado de tipos es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 4 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.
El problema: un tipo para muchos objetos invocables
Cada lambda tiene un tipo único. Cada puntero a función es un tipo diferente. Necesitamos un tipo que pueda contener cualquiera de ellos: std::function.
Parámetro de plantilla
std::function<Signature> recibe el tipo de retorno y los tipos de los parámetros. Acepta cualquier objeto invocable con esa signatura.
#include <functional>
std::function<int(int, int)> op;
op = [](int a, int b) { return a + b; };
std::cout << op(3, 4); // 7Almacenar distintos objetos invocables
La misma variable std::function puede contener una lambda, un puntero a función o un functor, siempre que la signatura coincida.
std::function<int(int)> f;
f = [](int x) { return x * 2; }; // lambda
f = ::abs; // function pointer
f = std::negate<int>{}; // functorBorrado de tipos
Internamente, std::function utiliza borrado de tipos: almacena cualquier objeto invocable y oculta su tipo real tras una interfaz uniforme. A menudo se implementa con una pequeña asignación en el montón.
Coste de rendimiento
La llamada mediante std::function implica una llamada indirecta (similar a una función virtual). Es más lenta que una llamada directa a una lambda. Evítela en rutas críticas.
Cuándo usar std::function
Úselo cuando:
- Almacene callbacks en un contenedor o como miembro de una clase
- Devuelva un objeto invocable desde una función
- Construya un sistema de plugins o eventos
std::function vacío
Un std::function construido de forma predeterminada está vacío. Al invocarlo, lanza std::bad_function_call.
std::function<void()> f;
if (f) f(); else std::cout << "no callback set";Punteros a funciones miembro
Vincule una función miembro con std::bind o envuélvala en una lambda.
struct Obj { void greet(int) {} };
Obj o;
std::function<void(int)> cb = [&](int n) { o.greet(n); };Comparación con punteros a funciones
Los punteros a funciones no pueden almacenar estado. std::function sí puede, a costa de realizar llamadas indirectas.
Comparación con plantillas
Las plantillas con parámetros invocables se especializan en tiempo de compilación y son las más rápidas. std::function resuelve en tiempo de ejecución: es más lenta, pero flexible.
template <typename F>
void run(F f) { f(); } // compile-time, no overhead
void run(std::function<void()> f) { f(); } // runtime, type erasurestd::function en C++23: std::function_ref
C++23 añadió std::function_ref, una vista no propietaria de un objeto invocable. Evita la asignación en el montón cuando la duración está acotada.
Alternativas
Existen alternativas ligeras: std::move_only_function (C++23), tl::function_ref y folly::Function. Elija según sus necesidades.
Comprobación rápida
¿Cuál es el principal inconveniente de std::function?
Resumen
std::function<Signature> almacena cualquier objeto invocable cuya signatura coincida. Es útil para callbacks, plugins y polimorfismo en tiempo de ejecución entre objetos invocables, a costa de realizar llamadas indirectas.
Preguntas frecuentes
¿La lección «std::function: objetos invocables con borrado de tipos» es gratis?
Sí — el texto completo de «std::function: objetos invocables con borrado de tipos» 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: objetos invocables con borrado de tipos»?
Oculte los tipos tras std::function y comprenda la optimización de búfer pequeño. 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 4 de 4.
¿Cuánto tiempo toma la lección «std::function: objetos invocables con borrado de tipos»?
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.
Todas las lecciones de este curso
- Objetos función y functors
- Capturas lambda por valor, por referencia y mutable
- Lambdas genéricas y cierres en C++14
- std::function: objetos invocables con borrado de tipos