Curso de C++ Avanzado para tu Equipo — Calidad y rendimiento de código
El curso de C++ Avanzado es una formación para empresas en Aula Virtual, en directo y a medida de cada equipo, bonificable hasta el 100% por FUNDAE. Su temario tiene 15 temas y está pensado para Desarrolladores C++, Senior Software Engineers y Software Architects.
- Modalidad
- Aula Virtual a medida, en directo
- Duración
- Personalizada
- Formador
- Experto en C++ Avanzado, en directo
- FUNDAE
- Bonificable hasta el 100 % · gestión incluida
Reserva ya tu formación con el crédito 2027
Bonificable hasta el 100 % según tu crédito FUNDAE · gestión incluida
Modalidad Aula Virtual Personalizada
Curso de C++ Avanzado en Aula Virtual Personalizada
Nuestra modalidad AVP es una formación en directo, práctica y 100% adaptada a vuestro equipo. No trabajamos con contenidos genéricos: diseñamos la formación en función de vuestro nivel, objetivos, procesos internos y necesidades reales de aplicación.
Solicitar informaciónTemario 100% a medida
Creamos el temario desde cero a partir de vuestras necesidades, nivel del equipo y objetivos concretos, priorizando aquellos contenidos que realmente aporten valor en el día a día.
Proyectos personalizados
Durante la formación trabajaremos con archivos, ejemplos, informes o procesos similares a los que utiliza vuestro equipo, para que el aprendizaje sea directamente aplicable al puesto de trabajo.
Sesiones en directo con consultor experto
Un formador especialista imparte las clases en tiempo real, resolviendo dudas, revisando casos concretos y adaptando el ritmo de la formación a la evolución del grupo.
Calendario adaptado a vuestra disponibilidad
Definimos conjuntamente fechas, horarios y duración de las sesiones para facilitar la asistencia del equipo y minimizar el impacto en la operativa diaria de la empresa.
Curso de C++ Avanzado hasta 100% Bonificable a través de FUNDAE
Tu bonificación paso a paso
Este programa de C++ Avanzado para empresas es bonificable hasta el 100 % según tu crédito FUNDAE.
Si tu crédito FUNDAE cubre el importe, el curso puede salirte a 0 €.
- Potencia las habilidades de programación de tus desarrolladores.
- Accede a una formación avanzada en C++ Avanzado práctica y orientada a resultados.
- Prepara a tu equipo para construir y mantener software de calidad.
- La gestión ante FUNDAE de la bonificación de este curso corporativo de C++ Avanzado está incluida.
Calcula tu bonificación
Revisamos tu caso
Preparamos la gestión
Tu equipo realiza el curso
Aplicas la bonificación
La formación que decides
te devuelve dinero
Todos nuestros cursos son bonificables a través de FUNDAE.
Gestionamos toda la documentación por ti.
Bonificable hasta el 100 % según tu crédito FUNDAE*
*Si el crédito disponible de tu empresa cubre el importe del curso. Calcula tu crédito y te confirmamos el coste neto.
Calcula tu crédito aproximado
Crédito bonificable estimado
897 €*
*Cálculo orientativo
Cobertura completa de C++ moderno
Capacita a tu equipo en C++ Avanzado con formación A Medida que optimiza concurrencia y calidad de código, bonificable por FUNDAE. Diseñamos el plan formativo.
Memoria segura RAII, smart pointers, ownership y lifetime permiten reducir leaks y errores de acceso.
Generic Programming moderno Templates, Concepts y compile-time programming se trabajan conjuntamente y evitando complejidad innecesaria.
Concurrencia avanzada Threads, atomics, memory ordering, sincronización y coroutines permiten abordar software paralelo y asíncrono.
Arquitectura profesional Interfaces, SOLID, módulos, plugins y dependency inversion facilitan proyectos mantenibles y extensibles.
Rendimiento medible Profiling y benchmarking sustituyen las suposiciones por evidencia antes de aplicar optimizaciones.
Calidad de producción Testing, mocking, sanitizers, fuzzing y análisis estático cubren defectos desde perspectivas complementarias.
Toolchain completa CMake, package management, compiladores, CI/CD y empaquetado se integran dentro del mismo ciclo de ingeniería.
Proyecto integrador realista El framework CLI combina arquitectura, concurrencia, templates, logging, testing, rendimiento y construcción profesional.
Personaliza el temario al 100% para tu equipo
Diseñamos una formación a medida utilizando los documentos y flujos de trabajo reales de tu empresa.
Temario del curso
Encuentra todo el temario del curso aquí.
Evolución del lenguaje desde C++03 hasta el estándar publicado C++23.
C++23 como revisión actualmente publicada mediante ISO/IEC 14882:2024 y situación de C++26 como siguiente estándar todavía en desarrollo.
Deducción de tipos mediante `auto`, `decltype` y `decltype(auto)`.
Inicialización uniforme, listas de inicialización y reglas para evitar conversiones inesperadas.
Range-based `for` y evolución de los patrones modernos de iteración.
Lambdas, capturas, generic lambdas y closures.
`nullptr`, scoped enums, `override`, `final` y otras mejoras de seguridad respecto al C++ clásico.
Constructores delegados, herencia de constructores y generación controlada de operaciones especiales.
Value categories, lvalues, rvalues, referencias universales y perfect forwarding.
Move semantics como base del diseño eficiente de tipos modernos.
`constexpr`, `consteval` y `constinit` para trasladar trabajo y validaciones a tiempo de compilación.
`if constexpr`, structured bindings y otras construcciones modernas para código más expresivo.
Explicit object parameters o deducing `this` incorporado en C++23.
`std::format`, `std::print` y `std::println` como evolución del formateo y salida estándar.
Criterios para modernizar código legacy progresivamente sin introducir cambios innecesarios de comportamiento.
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.
¿Tienes dudas?
Estamos aquí para ayudarte
Pensado para quienes deben dominar C++ Avanzado en su día a día
Desarrolladores C++
Profesionales que ya dominan los fundamentos y quieren profundizar en las capacidades modernas y avanzadas del lenguaje.
Senior Software Engineers
Perfiles responsables de componentes críticos, rendimiento, mantenibilidad y calidad técnica.
Software Architects
Profesionales que diseñan librerías, servicios, frameworks y sistemas modulares escritos en C++.
Systems Programmers
Desarrolladores que trabajan cerca del sistema operativo, networking, memoria, procesos o concurrencia.
Embedded Developers
Profesionales que utilizan C++ en sistemas con restricciones de rendimiento, memoria o plataforma.
Game Engine Developers
Perfiles que necesitan control de memoria, concurrencia, estructuras eficientes y alto rendimiento.
Quantitative Developers
Profesionales que desarrollan software intensivo en cálculo y sensible a latencia.
Technical Leads
Responsables de definir estándares de código, arquitectura, testing, build y rendimiento en equipos C++.
DevOps y Build Engineers
Perfiles responsables de CMake, toolchains, dependencias, CI/CD y distribución de software C++.
Plataforma
de e-learningFormación en directo con plataforma de apoyo para reforzar el aprendizaje
Acceso a las grabaciones
Las sesiones quedan grabadas para que cada alumno repase lo que necesite después de la clase en directo.
Recursos formativos
Materiales, sesiones grabadas y documentación de apoyo quedan centralizados en la plataforma para que el equipo pueda consultarlos durante y después de la formación.
Confirmación de asistencia
La plataforma registra las conexiones de cada participante: es la documentación que pide FUNDAE para bonificar el curso.
Ejercicios prácticos
Después de la formación en directo, los alumnos podrán acceder a ejercicios prácticos para aplicar lo trabajado en clase y consolidar el aprendizaje con actividades guiadas.
Acceso a las grabaciones
Las sesiones quedan grabadas para que cada alumno repase lo que necesite después de la clase en directo.
Recursos formativos
Materiales, sesiones grabadas y documentación de apoyo quedan centralizados en la plataforma para que el equipo pueda consultarlos durante y después de la formación.
Confirmación de asistencia
La plataforma registra las conexiones de cada participante: es la documentación que pide FUNDAE para bonificar el curso.
Ejercicios prácticos
Después de la formación en directo, los alumnos podrán acceder a ejercicios prácticos para aplicar lo trabajado en clase y consolidar el aprendizaje con actividades guiadas.
Practica y mejora con nuestra plataforma
Una plataforma con IA que corrige tus ejercicios al momento, explica cada fallo y te enseña cuánto has avanzado.
Corrección mágica
Feedback inteligente
Aprende de cada acierto y fallo con explicaciones claras
Empresas que ya han formado a sus equipos
Experiencias reales de equipos que ya han trabajado con nosotros.
+16
años de liderazgo
+4.500
empresas formadas
Mi empresa contrató un Aula Virtual Personalizada con Imagina, después de tener malas experiencias con otras academias y nos sorprendió la profesionalidad con la que trabajan. Hicimos 3 reuniones técnicas con Martín antes de empezar la formación y quedamos encantados con el resultado, sin duda repetiremos.
5Rafael Romero
Coordinador de formación corporativa
Hice un Aula Virtual Personalizada con mi empresa y estamos muy contentos, plantean proyectos evolutivos durante las sesiones y todo el contenido es muy práctico. El profesor, Gorka, fue súper majo con nosotros y tenía mucha paciencia. Sin duda repetiremos.
5Francisco Jose Moreno
Director en Marketing Digital
Me recomendó Imagina un amigo que lleva bastante tiempo contratando cursos para su empresa y estoy muy satisfecho del resultado, te dan todas las facilidades con la gestión en FUNDAE, los cursos son muy completos y tienen muchísima variedad.
5Pablo Álvarez
Ingeniero de Sistemas
El curso de Power BI Desktop es muy completo, enfocado en la práctica y con muy buenos contenidos. Muy eficientes en el contacto y con la resolución de dudas. 100% recomendable.
4Gabriel Perelló
Responsable de Recursos Humanos
480.000 alumnos formados en Imagina
Resolvemos todas tus dudas sobre nuestra formación en C++ Avanzado
Lo que más nos preguntan sobre el curso, la bonificación y las fechas.
El curso trabaja fundamentalmente con C++11 a C++23. ISO/IEC 14882:2024, que corresponde a C++23, es actualmente el estándar internacional publicado.
¿Tienes dudas?
Estamos aquí para ayudarte
Se revisan las líneas de evolución relevantes cuando ayudan a preparar el código para el futuro, pero C++26 todavía se encuentra en desarrollo y no sustituye al estándar publicado C++23.
¿Tienes dudas?
Estamos aquí para ayudarte
Sí. Se estudian requires, constraints, Concepts estándar y conceptos propios como alternativa moderna a gran parte del SFINAE tradicional.
¿Tienes dudas?
Estamos aquí para ayudarte
Sí. Se estudia la transición desde headers a C++20 Modules y su integración con toolchains y CMake actuales. CMake incorporó soporte específico para dependencias de módulos en 3.28.
¿Tienes dudas?
Estamos aquí para ayudarte
Sí. Threads, mutexes, atomics, memory ordering, futures, jthread, barriers, latches, thread pools y cancelación forman parte del programa.
¿Tienes dudas?
Estamos aquí para ayudarte
Sí. Se estudian las coroutines incorporadas en C++20 y su relación con std::generator, incorporado al estándar en C++23.
¿Tienes dudas?
Estamos aquí para ayudarte
Sí. GoogleTest se trabaja como framework principal de testing y mocking, y Catch2 se incluye como alternativa habitual en el ecosistema C++.
¿Tienes dudas?
Estamos aquí para ayudarte
Sí. El curso incluye profiling, Google Benchmark, optimizaciones de compilador, LTO, PGO, SIMD, caché, asignaciones, copy elision y análisis de CPU y memoria.
¿Tienes dudas?
Estamos aquí para ayudarte
Sí. AddressSanitizer, UndefinedBehaviorSanitizer, ThreadSanitizer y fuzzing se incorporan junto con testing y análisis estático.
¿Tienes dudas?
Estamos aquí para ayudarte
Sí. Se estudian extern "C", linking, wrappers RAII, ABI, carga dinámica y patrones aplicables a bibliotecas como SQLite, OpenSSL o libcurl.
¿Tienes dudas?
Estamos aquí para ayudarte
No. Se parte de templates conocidos por un desarrollador intermedio y se avanza hacia traits, variadic templates, if constexpr, Concepts y técnicas compile-time.
¿Tienes dudas?
Estamos aquí para ayudarte
No. Los conceptos son multiplataforma y pueden trabajarse con GCC, Clang o MSVC. Determinadas herramientas de profiling o linking se adaptarán al sistema operativo utilizado.
¿Tienes dudas?
Estamos aquí para ayudarte
La formación puede ser bonificable a través de FUNDAE hasta el 100% cuando la empresa dispone de crédito formativo suficiente y se cumplen los requisitos aplicables a la Formación Programada por las Empresas.
¿Tienes dudas?
Estamos aquí para ayudarte
Tutoriales de Lenguajes
¿Qué es Spring Framework y Cómo usarlo?
22 de octubre de 2025¿Qué es el Lenguaje GO y Cómo Aprenderlo?
03 de julio de 2025Los 3 Mejores Frameworks de Java
04 de junio de 2025¿Qué es PERL? Lenguaje de Programación
09 de enero de 2025¿Qué es Groovy? Lenguaje de Programación
09 de enero de 2025Otros cursos para tu equipo
C
Este curso proporciona una introducción al lenguaje de programación C. El curso comprende conceptos fundamentales como variables, tipos de datos, estructuras de control de flujo, funciones, punteros y estructuras de datos. El curso está diseñado para ayudar a los participantes a adquirir una comprensión sólida de cómo funciona el lenguaje de programación C en entornos reales.
Introducción a la Robótica con C++
Aprende a programar robots en C++ desde el principio con este curso
Buenas Prácticas en C++
Mejora la calidad de tu código haciendo uso de buenas prácticas y lleva tu código al siguiente nivel.
Diseñemos hoy el curso que tu empresa necesita
Cuéntanos qué necesita tu equipo y te preparamos una propuesta bonificable a su medida.
