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

Limitaciones de `new` / `delete`

`unique_ptr`, `shared_ptr`, `weak_ptr`

Factory functions y `make_unique` / `make_shared`

Ciclos de referencia y `weak_ptr`

Práctica: refactor de punteros crudos a smart pointers

Control de propiedad y RAII

Custom deleters y memory policies

Uso en containers y paso por valor o referencia

Riesgos de `shared_ptr` y debugging

Buenas prácticas con memoria automática

Internals de `vector`, `map`, `unordered_map`, `deque`, etc.

`emplace_back`, `insert` y performance

Iteradores: tipos y adaptadores

`std::span` y `std::array`

Comparación con Boost containers

Práctica: implementación de un mini ORM con `map<string, variant>`

Errores comunes con iteradores

Iteradores invalidated y soluciones

Containers personalizados

Técnicas para usar containers de forma segura

`std::sort`, `std::transform`, `std::accumulate`, etc.

Uso de lambdas con algoritmos

`std::ranges` (C++ v20) y vistas

Proyecciones y filtros

Práctica: filtrado y mapeo funcional con ranges

Custom comparators y predicados

`std::find_if`, `all_of`, `any_of`

Técnicas para evitar loops explícitos

Buenas prácticas de diseño funcional

`std::execution` y paralelismo

Templates de función y clase

Template specialization y partial specialization

SFINAE y `std::enable_if`

Variadic templates

Fold expressions (C++ v17)

Práctica: crear función `log()` con N argumentos

Deducción de tipos y `auto` en plantillas

Integración con `decltype` y `constexpr if`

Detección de características (`is_same`, `is_base_of`)

Templates recursivos y elegantes

¿Qué son los `concepts` y para qué sirven?

Reemplazo moderno de SFINAE

`requires` clause y constraints

Conceptos predefinidos (`integral`, `floating_point`, etc.)

Definir conceptos propios

Práctica: template `sumar()` que solo acepte numéricos

Integración con `auto` y `decltype(auto)`

Concepts vs enable_if

Impacto en el diseño de APIs

Errores más comunes

Jerarquía de excepciones estándar

`throw`, `try/catch`, `noexcept`

`std::optional`, `std::variant`, `std::expected` (C++ v23)

Práctica: refactorizar función que devuelve múltiples tipos

Personalización de `what()` y mensajes

Gestión sin excepciones (por error code)

`assert`, `static_assert`, y validaciones

Error handling en funciones de bajo nivel

Comparativa de estrategias

Errores en constructores y destructores

Organización por módulos lógicos

Separación de headers e implementación

Encapsulamiento avanzado (`friend`, `mutable`)

Namespaces anidados, inline y `using`

Práctica: crear mini-librería con interfaz pública clara

Design patterns (RAII, Builder, Factory)

Módulos en C++ v20 (`export module`)

Control de visibilidad y linkage

Testing en arquitectura modular

Buenas prácticas en diseño en capas

`std::thread`, `std::mutex`, `std::condition_variable`

`std::atomic`, `std::memory_order`

`std::async`, `std::future`, `std::promise`

Práctica: pool de threads con trabajo concurrente

`std::jthread` y cancelación (C++ v20)

`std::barrier`, `std::latch` (C++ v20)

Locks (`lock_guard`, `unique_lock`, `scoped_lock`)

Riesgos: race conditions, deadlocks

Técnicas de sincronización

Uso de `thread_local`

Especificaciones y arquitectura del sistema

Logger concurrente con buffer circular

Configuración en tiempo de ejecución

Selección de nivel (`info`, `warn`, `error`)

Escritor asíncrono a archivo

Uso de `std::thread`, `std::mutex`, `std::condition_variable`

Signals o shutdown clean

Unit tests del logger

Benchmarks con alta concurrencia

Empaquetado como librería para reuso

¿Qué es la metaprogramación?

`constexpr` y evaluación en tiempo de compilación

Técnicas de recursión estática con templates

`std::integral_constant`, `std::true_type`, `std::false_type`

`std::conditional`, `std::enable_if`, `std::is_same`, etc.

Práctica: selector de tipo en tiempo de compilación

`if constexpr` y simplificación de lógica

Metafunciones y traits personalizados

Limitaciones de metaprogramación clásica

Metaprogramación vs runtime: cuándo elegir

Punteros a métodos de clase: sintaxis y uso

`std::function` y `std::bind`

Captura de lambdas como callbacks

Delegación dinámica con punteros

Práctica: sistema de eventos tipo Observer

Functors y operadores `()`

Conversiones implícitas y riesgos

Uso con templates y funciones genéricas

`std::invoke` y adaptadores funcionales

Comparación: function vs pointer vs lambda

Serialización manual con buffers

Serializar estructuras POD

`std::stringstream`, `std::ostringstream`

Formatos: JSON (`nlohmann/json`), XML (`pugixml`) y binario

Práctica: guardar y leer configuración serializada

Gestión de versiones de estructuras

Serialización de punteros y relaciones

Comparación: boost::serialization vs C++ puro

Seguridad y validación de entradas

Deserialización resiliente

Principios del testing profesional

Instalación y uso de Google Test

Organización de tests por suite y caso

Matchers personalizados

Mocking de dependencias

Práctica: tests de una librería matemática

Fixtures y setups

Coverage con `gcov`, `lcov`, `llvm-cov`

Integración con CI/CD

Test Driven Development (TDD) aplicado a C++

Llamadas a código C desde C++

Uso de `extern "C"` para compatibilidad

Compilación cruzada y linking mixto

Práctica: integración con librería externa `.so`

Conversión de `structs` entre lenguajes

`dlopen`, `dlsym`, y linking dinámico

Definición de interfaces compartidas

Gestión de errores y tipos entre lenguajes

Wrappers de clases C++ para librerías C

Casos reales: SQLite, OpenSSL, libcurl

`inline`, `constexpr`, `restrict`, `likely` y `unlikely`

Profiling con `perf`, `gprof`, `callgrind`, `google-perftools`

Práctica: microbenchmark con Google Benchmark

Flags de compilación `-O1`, `-O2`, `-O3`, `-Ofast`, `-march=native`

Vectorización automática y SIMD

Reducción de copia con `move` y `emplace`

Copy elision y Return Value Optimization (RVO)

Técnicas de inlining inteligente

Medición de uso de CPU/memoria en tiempo real

Optimización de estructuras de datos

Principios SOLID en C++

Interfaces puras y polimorfismo dinámico

Patrón Bridge para desacoplar capas

Práctica: plugin cargado dinámicamente con interfaz abstracta

Delegación y composición

Inversión de dependencias

Factories y Service Locators

Interface-based design vs inheritance

Mocking a través de interfaces

Separación de responsabilidades

Diseño de clases con strong exception guarantee

Copy-and-swap idiom

RAII aplicado a recursos frágiles

Práctica: clase con mutex y control de rollback

Estabilidad ante fallos y reversión parcial

Técnicas para evitar leaks en paths excepcionales

`noexcept`, `try/catch` internos

Destructores sin excepciones

Logs y trazabilidad de errores críticos

Políticas de manejo global (handlers, abort)

Problemas clásicos de los headers

Introducción a `export module`, `import`

Cómo definir y consumir un módulo

Práctica: refactor de librería a módulos

Integración con CMake y herramientas actuales

Diferencias con headers clásicos

Recompilación y ventajas de rendimiento

Modularización gradual de proyectos legacy

Interoperabilidad con bibliotecas externas

Estado actual de soporte en compiladores

Diseño de un framework de línea de comandos extensible

Arquitectura desacoplada por módulos

Parsers con templates y `std::variant`

Logging asíncrono

Sistema de comandos y eventos

Concurrencia: ejecución de comandos en background

Tests unitarios y funcionales

Documentación técnica automática

Benchmark y profiling

Empaquetado final con CMake y documentación