Eliminadores personalizados y funciones make
Use std::make_unique, std::make_shared y eliminadores personalizados para recursos que no sean memoria.
Eliminadores personalizados y funciones make 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.
¿Por qué usar eliminadores personalizados?
No todos los recursos se liberan con delete. Los identificadores de archivos, los sockets, los recursos específicos del sistema operativo y los arrays necesitan funciones de limpieza diferentes.
Eliminador predeterminado de unique_ptr
De forma predeterminada, unique_ptr<T> usa delete. Para arrays, use unique_ptr<T[]>, que llama a delete[].
Especificar un eliminador personalizado
Pase un objeto invocable como segundo argumento de plantilla. El eliminador recibe el puntero sin formato y lo libera correctamente.
auto closer = [](FILE* f) { if (f) std::fclose(f); };
std::unique_ptr<FILE, decltype(closer)> file(
std::fopen("data.txt", "r"), closer);Eliminador de shared_ptr
shared_ptr almacena su eliminador en el bloque de control. El tipo se borra, por lo que el tipo de shared_ptr no cambia.
std::shared_ptr<FILE> file(
std::fopen("data.txt", "r"),
[](FILE* f) { if (f) std::fclose(f); }
);Casos de uso habituales de eliminadores personalizados
Ejemplos del mundo real:
- Identificadores de bibliotecas de C (FILE*, sqlite3*, identificadores de curl)
- Recursos del sistema operativo (HANDLE en Windows, fd en Unix)
- Grupos de memoria personalizados
- Objetos externos con conteo de referencias
std::make_unique (C++14)
La forma recomendada de crear un unique_ptr. Reenvía los argumentos al constructor y evita el uso de new sin formato.
auto p = std::make_unique<Widget>(arg1, arg2);¿Por qué make_unique?
Tres ventajas:
- Seguridad frente a excepciones: no hay
newsin formato en el código del usuario - No es necesario escribir el tipo dos veces
- No se puede pasar accidentalmente el puntero sin formato a dos unique_ptr
std::make_shared
Para shared_ptr, make_shared asigna el bloque de control y el objeto en una sola asignación en el heap, lo que es más rápido que hacer asignaciones independientes.
auto p = std::make_shared<Widget>(arg1, arg2);Cuándo make_shared presenta desventajas
La asignación única implica que la memoria del objeto solo se libera cuando también han desaparecido todos los weak_ptr. Si sus weak_ptr sobreviven a los shared_ptr, prefiera la construcción en dos pasos.
Combinar eliminadores personalizados con make
make_unique y make_shared no aceptan directamente un eliminador personalizado. En ese caso, construya manualmente el puntero inteligente.
// make_shared cannot take a deleter
std::shared_ptr<FILE> file(
std::fopen("data.txt", "r"),
[](FILE* f) { if (f) std::fclose(f); }
);Problema: el tipo de lambda como parámetro de plantilla
Cada lambda tiene un tipo único. Para unique_ptr, use decltype(my_deleter) al declarar el puntero; también puede usar una función con nombre o un puntero a función para mantener los tipos simples.
Comprobación rápida
¿Qué función de fábrica permite asignar un std::shared_ptr y su bloque de control en una sola asignación en el heap?
Resumen
Use make_unique y make_shared en los casos habituales. Proporcione un eliminador personalizado, como una lambda o una función, cuando el recurso necesite algo más que delete: identificadores de archivos, objetos del sistema operativo o limpieza de bibliotecas de C.
Preguntas frecuentes
¿La lección «Eliminadores personalizados y funciones make» es gratis?
Sí — el texto completo de «Eliminadores personalizados y funciones make» 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 «Eliminadores personalizados y funciones make»?
Use std::make_unique, std::make_shared y eliminadores personalizados para recursos que no sean memoria. 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 «Eliminadores personalizados y funciones make»?
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
- Por qué los punteros inteligentes sustituyen a new y delete sin formato
- unique_ptr y propiedad exclusiva
- shared_ptr y weak_ptr: propiedad compartida
- Eliminadores personalizados y funciones make