Curso de C++ Avanzado para tu Equipo — Calidad y rendimiento de código

Limitaciones y riesgos del uso directo de `new` y `delete`.

RAII como principio fundamental para gestionar memoria, ficheros, locks, sockets y otros recursos.

`std::unique_ptr` como modelo de propiedad exclusiva.

`std::shared_ptr` para propiedad compartida y análisis de su coste.

`std::weak_ptr` para romper ciclos de referencias.

`std::make_unique` y `std::make_shared` como patrones habituales de construcción.

Custom deleters para recursos que necesitan una política de liberación específica.

Transferencia de ownership mediante move semantics.

Criterios para pasar smart pointers, referencias, punteros observadores y objetos por valor.

Riesgos de abuso de `shared_ptr` y detección de ownership mal definido.

Lifetime, dangling pointers y referencias que sobreviven incorrectamente a sus objetos.

Uso seguro de `std::span` y `std::string_view` como vistas no propietarias.

Allocators y `std::pmr::polymorphic_allocator` para controlar estrategias de asignación.

Memory resources y reducción del coste de asignaciones en cargas intensivas.

Diseño de APIs donde la propiedad y duración de los objetos puedan deducirse claramente desde la interfaz.

Arquitectura y comportamiento interno de `vector`, `deque`, `list`, `map`, `set` y containers unordered.

Selección del container según acceso, inserción, ordenación, localidad de memoria y complejidad algorítmica.

`std::array`, `std::span` y vistas no propietarias sobre almacenamiento contiguo.

`std::mdspan` de C++23 para representar vistas multidimensionales sin ownership.

`std::flat_map` y `std::flat_set` de C++23 y sus diferencias respecto a estructuras basadas en nodos.

`push_back`, `emplace_back`, `insert`, `emplace` y coste real de construcción y movimiento.

Iteradores, categorías, sentinels y adaptadores.

Reglas de invalidación de iteradores, referencias y punteros según cada container.

`std::sort`, `find_if`, `transform`, `accumulate`, `all_of`, `any_of` y algoritmos relacionados.

Lambdas, comparadores, proyecciones y predicados reutilizables.

`std::ranges` y composición declarativa de algoritmos desde C++20.

Views para filtrado, transformación, slicing, combinación y evaluación lazy.

Nuevas operaciones de ranges incorporadas en C++23 y compatibilidad dependiente de la biblioteca estándar utilizada.

Execution policies con `std::execution::seq`, `par` y `par_unseq` para algoritmos paralelizables.

Modelado de registros heterogéneos mediante estructuras como `map<string, variant<...>>` y comparación con containers especializados o Boost.

Templates de función y de clase como base del generic programming en C++.

Deducción de parámetros y reglas de instanciación.

Specialization y partial specialization.

Variadic templates para APIs con número variable de parámetros tipados.

Pack expansion y fold expressions introducidas en C++17.

SFINAE y `std::enable_if` como mecanismo histórico de restricción.

Type traits estándar como `is_same`, `is_base_of`, `is_integral` y categorías relacionadas.

`std::integral_constant`, `true_type`, `false_type` y `conditional`.

Metafunciones y traits personalizados para describir propiedades de tipos.

`if constexpr` para eliminar ramas de código en compilación.

Concepts de C++20 como evolución de la programación genérica restringida.

`requires` expressions, requires clauses y composición de constraints.

Concepts estándar como `integral`, `floating_point`, `same_as` y familias relacionadas.

Diseño de concepts propios para expresar contratos semánticos de una API.

Estrategias para sustituir metaprogramación recursiva y SFINAE compleja por constructs más legibles y diagnosticables.

Punteros a funciones y diferencias respecto a objetos invocables modernos.

Punteros a miembros y métodos de clase.

Functors mediante sobrecarga de `operator()`.

Lambdas como objetos funcionales generados por el compilador.

Captura por valor, referencia y move capture.

Generic lambdas y utilización con tipos deducidos.

`std::function` como wrapper type-erased de callables.

Costes de type erasure, asignación y dispatch asociados a `std::function`.

`std::move_only_function` de C++23 para callables no copiables.

`std::bind`, placeholders y alternativas actuales basadas en lambdas.

`std::invoke` y llamada uniforme de funciones, functors y miembros.

Diseño de callbacks, observers y buses de eventos desacoplados.

Jerarquía de excepciones de la biblioteca estándar.

`throw`, `try`, `catch` y propagación de excepciones.

`noexcept` como parte del contrato y de las posibilidades de optimización.

Diferencia entre excepciones, códigos de error y valores de retorno explícitos.

`std::optional` para representar ausencia de valor.

`std::variant` para resultados pertenecientes a un conjunto cerrado de tipos.

`std::expected` de C++23 para modelar resultado o error sin recurrir necesariamente a excepciones.

Operaciones monádicas sobre `optional` y `expected` disponibles en C++23.

`assert` y `static_assert` para invariantes de runtime y compilación.

Excepciones en constructores y reglas para destructores seguros.

Basic, strong y no-throw exception guarantees.

Copy-and-swap como técnica para mantener estado consistente ante errores.

RAII aplicado a rollback y recursos adquiridos parcialmente.

`std::source_location` y `std::stacktrace` para enriquecer diagnóstico y trazabilidad.

Diseño de políticas globales de error, recuperación, logging y terminación controlada.

Organización de proyectos C++ por responsabilidades y dominios.

Separación tradicional entre headers e implementación.

Encapsulamiento avanzado mediante `friend`, `mutable` y visibilidad controlada.

Namespaces anidados, inline namespaces y aliases.

Linkage interno, externo y ODR como fundamentos de una arquitectura mantenible.

Principios SOLID aplicados de forma pragmática a C++.

Interfaces abstractas y polimorfismo dinámico.

Composición frente a herencia para reducir acoplamiento.

Dependency Inversion y construcción de dependencias desde capas externas.

Factory, Builder, Bridge y otros patrones útiles en arquitecturas C++.

Factories y service registries frente al uso indiscriminado de Service Locator.

Diseño orientado a interfaces para facilitar sustitución y testing.

Módulos de C++20 mediante `export module`, `import` y module partitions.

Migración gradual desde headers hacia módulos y convivencia con librerías tradicionales.

Control de dependencias y límites arquitectónicos para evitar proyectos monolíticos difíciles de compilar y mantener.

Modelo de concurrencia de C++ y relación entre threads, tareas y memoria compartida.

`std::thread` y gestión explícita del ciclo de vida de un hilo.

`std::jthread`, `std::stop_token` y cancelación cooperativa desde C++20.

`std::mutex`, `recursive_mutex` y mecanismos básicos de exclusión.

`lock_guard`, `unique_lock` y `scoped_lock`.

`std::condition_variable` para coordinación entre productores y consumidores.

`std::future`, `std::promise` y `std::async`.

`std::atomic` y operaciones lock-free cuando la plataforma las soporta.

Modelo de memoria y órdenes `relaxed`, `acquire`, `release` y `seq_cst`.

Race conditions, deadlocks, livelocks, starvation y false sharing.

`std::latch` y `std::barrier` para sincronización de grupos de tareas.

`thread_local` y aislamiento de estado por hilo.

Diseño de thread pools, colas de trabajo y procesamiento concurrente.

Coroutines de C++20 mediante `co_await`, `co_yield` y `co_return`.

`std::generator` de C++23 para representar generadores síncronos como ranges cuando la toolchain lo soporte.

Serialización manual mediante buffers y control explícito del formato.

Diferencias entre representación en memoria y formato persistente.

Serialización de estructuras trivially copyable y limitaciones de copiar memoria directamente.

Endianness, padding, alignment y portabilidad de formatos binarios.

`stringstream`, `ostringstream` y flujos estándar para transformación de datos.

JSON mediante librerías consolidadas como `nlohmann/json`.

XML mediante alternativas como `pugixml`.

Formatos binarios para escenarios donde tamaño y velocidad son prioritarios.

Versionado de estructuras y evolución compatible de schemas.

Representación de relaciones, referencias e identidades sin serializar direcciones de memoria.

Comparación conceptual entre serialización manual, bibliotecas específicas y Boost.Serialization.

Validación estricta de entradas antes de construir objetos.

Protección frente a tamaños maliciosos, desbordamientos y estructuras corruptas.

Deserialización tolerante a versiones anteriores y errores recuperables.

Llamadas desde C++ hacia APIs escritas en C.

`extern "C"` y control del name mangling.

Diseño de estructuras ABI-safe en fronteras entre lenguajes.

Conversión de structs y tipos entre APIs C y modelos C++.

Wrappers RAII sobre recursos proporcionados por bibliotecas C.

Propagación y traducción de errores entre modelos distintos.

Linking estático frente a linking dinámico.

Bibliotecas `.so`, `.dylib` y `.dll` según plataforma.

`dlopen`, `dlsym` y mecanismos equivalentes para carga dinámica.

Interfaces estables para desarrollar arquitecturas de plugins.

Compatibilidad ABI, versionado y riesgos de exponer tipos STL a través de fronteras binarias.

Integración de bibliotecas habituales como SQLite, OpenSSL o libcurl mediante wrappers seguros y desacoplados.

Diseño de una estrategia de testing para librerías y aplicaciones C++.

Unit, integration, component y end-to-end testing.

GoogleTest como framework consolidado de testing y mocking para C++.

Catch2 como alternativa para proyectos que prefieren una sintaxis diferente.

Organización de tests por suites, casos y responsabilidades.

Fixtures, parametrización y reutilización de setup.

Matchers personalizados para expresar verificaciones de dominio.

Mocking de dependencias y sustitución de interfaces.

TDD aplicado a componentes donde el enfoque aporta claridad de diseño.

Coverage mediante `gcov`, `lcov` y `llvm-cov`.

AddressSanitizer para detectar accesos de memoria incorrectos.

UndefinedBehaviorSanitizer y ThreadSanitizer para UB y errores concurrentes.

Fuzz testing para descubrir combinaciones de entrada inesperadas.

Static analysis mediante herramientas como `clang-tidy` y analizadores complementarios.

Integración de compilación, tests, sanitizers, análisis y coverage dentro de CI/CD.

Optimización basada en mediciones frente a optimización prematura.

Flags `-O1`, `-O2`, `-O3` y análisis de las implicaciones de configuraciones más agresivas.

`-march=native` y relación entre optimización específica y portabilidad del binario.

Link-Time Optimization y Profile-Guided Optimization.

`inline` como mecanismo semántico y decisiones reales de inlining del compilador.

`constexpr` para trasladar determinados cálculos a compilación.

`[[likely]]` y `[[unlikely]]` como hints para ramas.

Extensiones `__restrict` o equivalentes del compilador y sus compromisos de portabilidad.

Copy elision, RVO, move semantics y eliminación de copias innecesarias.

Localidad de caché, layouts de datos y selección de containers.

Auto-vectorización y utilización de SIMD.

Profiling con `perf`, `gprof`, Valgrind/Callgrind y herramientas equivalentes de plataforma.

Google Benchmark para microbenchmarks reproducibles.

Análisis de CPU, memoria, allocations, cache misses y contention.

Interpretación de benchmarks evitando optimizaciones eliminadas, warm-up incorrecto o mediciones estadísticamente débiles.

Diseño target-based con CMake moderno.

`target_link_libraries`, `target_include_directories` y propagación correcta de requisitos.

Targets `PRIVATE`, `PUBLIC` e `INTERFACE`.

Organización de librerías estáticas, compartidas, ejecutables y componentes internos.

Toolchain files para compilación cruzada y entornos especializados.

CMake Presets para compartir configuraciones reproducibles entre desarrolladores y CI.

Integración de GoogleTest, benchmarks y otras herramientas dentro del build.

`FetchContent`, paquetes preinstalados y estrategias de gestión de dependencias.

Uso de Conan o vcpkg cuando el proyecto necesita un gestor de paquetes externo.

Instalación, exportación y creación de paquetes consumibles por otros proyectos.

RPATH, runtime dependencies y distribución de bibliotecas dinámicas.

Configuraciones Debug, Release, RelWithDebInfo y sanitizers.

Integración de C++ Modules en el grafo de compilación.

CMake soporta el seguimiento de dependencias de módulos C++ desde la versión 3.28 mediante escaneo y ordenación del build.

Builds reproducibles, cachés de compilación y estrategias para reducir tiempos de integración continua.

Arquitectura de un sistema de logging reutilizable y thread-safe.

Niveles `trace`, `debug`, `info`, `warn`, `error` y `critical`.

Configuración de niveles y sinks durante la ejecución.

Cola o buffer circular para desacoplar productores y escritor.

Escritura asíncrona a fichero sin bloquear el thread de aplicación.

Coordinación mediante mutex, condition variables y mecanismos modernos de parada.

`std::jthread` y `stop_token` para shutdown cooperativo.

Flush controlado y garantía de entrega durante el cierre.

Timestamps, thread IDs y contexto estructurado asociado a cada entrada.

`std::source_location` para capturar archivo, función y línea sin repetir argumentos.

`std::stacktrace` de C++23 cuando la biblioteca estándar de la toolchain proporcione soporte.

Testing, benchmarking con alta concurrencia y empaquetado del logger como librería reutilizable.

Integración de logs con métricas, traces y sistemas externos cuando la aplicación necesita observabilidad distribuida.

Diseño de un framework de línea de comandos modular y extensible.

Separación de interfaz pública, dominio, infraestructura y adaptadores.

Utilización de módulos o headers según compatibilidad de la toolchain seleccionada.

Parser de argumentos basado en templates, concepts y `std::variant`.

Sistema de comandos extensible mediante interfaces desacopladas.

Registro dinámico de comandos y callbacks.

Arquitectura de eventos para reducir dependencias entre componentes.

Ejecución de tareas en foreground y background.

Concurrencia mediante `jthread`, colas de trabajo y cancelación cooperativa.

Logging asíncrono reutilizando la arquitectura desarrollada durante el curso.

Manejo de errores mediante excepciones, `expected`, valores opcionales y políticas diferenciadas según la capa.

Tests unitarios, integración, sanitizers y cobertura de los componentes principales.

Benchmarking y profiling sobre parsing, dispatch, logging y ejecución concurrente.

Build, instalación y empaquetado mediante CMake con dependencias y configuraciones reproducibles.

Documentación técnica, CI/CD y preparación de la librería para mantenimiento y evolución posteriores.