cpp

Conceptos de C++

  • Case y tipo de compilación
    • C++ es un lenguaje case-sensitive.
    • Compilado y con tipado estático, lo que significa que los tipos se verifican en tiempo de compilación.
  • Optimización
    • Manejo de memoria a nivel de bits y bytes.
      • 1 bit = 0 o 1
      • 1 byte = 8 bits
    • Optimización del código mediante uso eficiente de memoria y CPU.
  • STL y Templates
    • La Standard Template Library (STL) ofrece contenedores, algoritmos y funciones genéricas.
    • Templates permiten escribir código genérico reutilizable.
  • Acumuladores y estructuras básicas
    • Variables que guardan resultados acumulativos.
    • Uso de estructuras (struct) y clases (class) para organizar datos y lógica.

Compilación

  • Entornos recomendados:
  • Diferencias clave:
    • MSYS2: más cercano a Linux/UNIX, flexible, open-source.
    • MSVC: integración completa con Windows y Visual Studio, depuración avanzada.

Recursos para estudio

Historia y evolución de C++

  • Creado por Bjarne Stroustrup a principios de los años 80 como una extensión de C, añadiendo programación orientada a objetos (OOP).
  • Evolución destacada:
    • C++98 / C++03: primeras estandarizaciones con STL básica.
    • C++11: introducción de auto, smart pointers, lambdas, move semantics.
    • C++14: mejoras menores y optimización de lambdas y templates.
    • C++17: filesystem, optional, variant, structured bindings.
    • C++20: concepts, coroutines, ranges, módulos, improved constexpr.
  • Permite combinar eficiencia de C con abstracciones modernas.

Paradigmas de programación

  • Procedural: basado en funciones y control de flujo lineal.
  • Orientado a objetos (OOP): encapsulación, herencia y polimorfismo.
  • Genérico: uso de templates para escribir código reusable e independiente de tipos.
  • Funcional limitado: lambdas y funciones como objetos, expresiones const y algoritmos STL.

Tipos de datos avanzados y punteros

  • Tipos fundamentales: int, float, double, char, bool, void.
  • Tipos derivados: arrays, punteros, referencias.
  • Punteros:
    • Direcciones de memoria y manipulación directa.
    • Punteros a funciones y clases.
    • Smart pointers: unique_ptr, shared_ptr, weak_ptr para manejo seguro de memoria.
  • Tipos compuestos: struct, class, union, enum, bit-fields.

Manejo de memoria y RAII

  • RAII (Resource Acquisition Is Initialization): técnica para gestionar recursos automáticamente a través de constructores y destructores.
  • Memoria dinámica:
    • new y delete
    • Evitar fugas de memoria mediante smart pointers.
  • Optimización: minimizar copias innecesarias, usar move semantics (std::move).

Namespaces y modularidad

  • Namespaces permiten organizar código y evitar conflictos de nombres.
  • Ejemplo:
namespace Math {
	int add(int a, int b) { return a + b; }
}

`

  • Módulos (C++20): alternativa moderna a headers tradicionales, mejorando tiempos de compilación y encapsulación.

Excepciones y manejo de errores

  • Uso de try, catch, throw para capturar y manejar errores.
  • Ejemplo:
try {
	if (x == 0) throw std::runtime_error("División por cero");
	int y = 10 / x;
} catch (const std::exception& e) {
	std::cerr << e.what();
}
  • Buenas prácticas: lanzar excepciones solo en casos excepcionales, no para control de flujo normal.

Funciones, sobrecarga y operadores

  • Funciones: definición, prototipos, parámetros por valor o referencia.
  • Sobrecarga de funciones: varias funciones con mismo nombre pero diferente firma.
  • Operadores sobrecargados: redefinir +, -, *, << para clases personalizadas.
  • Funciones inline y constexpr para optimización y cálculo en tiempo de compilación.

Clases, objetos, herencia, polimorfismo y encapsulación

  • Clases y objetos: encapsulan datos y comportamiento.
  • Herencia: permite crear jerarquías de clases (public, protected, private).
  • Polimorfismo:
    • Estático: templates y funciones sobrecargadas.
    • Dinámico: punteros/referencias a clases base y métodos virtuales.
  • Encapsulación: uso de private y protected para controlar acceso a datos.

Plantillas avanzadas

  • Templates permiten generar código genérico:
template<typename T>
T sum(T a, T b) { return a + b; }
  • Template metaprogramming: cálculo en tiempo de compilación usando recursion y traits.
  • Ejemplos: std::is_same, std::enable_if, conceptos de C++20.

Librerías estándar y externas

  • STL (Standard Template Library):
    • Contenedores: vector, list, map, unordered_map.
    • Algoritmos: sort, find, accumulate.
    • Iteradores y adaptadores.
  • Boost: librerías externas avanzadas para gráficos, threads, regex, smart pointers, etc.
  • Otros ejemplos: Qt (GUI), Poco (networking), Eigen (matrices y álgebra lineal).

Buenas prácticas de código y compilación

  • Separar declaraciones (.h) de implementación (.cpp).
  • Usar const, referencias y smart pointers para seguridad y eficiencia.
  • Evitar macros innecesarias; preferir constexpr, inline y templates.
  • Mantener código modular y reutilizable con namespaces y clases.
  • Compilar con warnings activados (-Wall, /W4) y analizar performance.

Ejemplos de uso real y patrones de diseño

  • Patrones comunes:
    • Singleton: control de instancias globales.
    • Factory: creación flexible de objetos.
    • Observer: notificación de cambios entre objetos.
    • RAII para manejo de archivos y memoria.
  • Ejemplo real: Motor de videojuegos:
    • Clases para entidades (jugador, enemigo).
    • Punteros inteligentes para manejo de recursos gráficos.
    • Templates para algoritmos de física genéricos.
    • STL para contenedores de objetos y algoritmos de actualización.

C++ Core y Arquitectura

Núcleo de C++ (Core)

  • Compilación y tipado
    • Lenguaje compilado, tipado estático y fuerte.
    • Permite optimizaciones en tiempo de compilación.
  • Memoria y recursos
    • Acceso directo a memoria mediante punteros y referencias.
    • RAII: manejo seguro de recursos con constructores y destructores.
  • Funciones y control
    • Funciones, sobrecarga y operadores para abstracción.
    • Lambdas y funciones inline para eficiencia.
  • Templates y metaprogramming
    • Templates permiten código genérico y reusable.
    • Template metaprogramming para cálculos en tiempo de compilación.
  • STL (Standard Template Library)
    • Contenedores (vector, map, list) y algoritmos (sort, accumulate, find).
    • Iteradores, adaptadores y funciones genéricas.

Arquitectura de C++

  • Organización modular
    • Separación en headers (.h) y archivos de implementación (.cpp).
    • Namespaces para evitar colisiones de nombres y organizar lógica.
    • Módulos (C++20) como alternativa moderna a headers tradicionales.
  • Objetos y clases
    • Clases encapsulan datos y comportamientos.
    • Herencia, polimorfismo y encapsulación permiten arquitectura flexible.
  • Gestión de recursos
    • Punteros inteligentes (unique_ptr, shared_ptr, weak_ptr).
    • RAII y scope-based resource management.
  • Manejo de errores
    • Excepciones (try, catch, throw) para control centralizado de errores.
    • Uso combinado con recursos automáticos para código seguro y limpio.
  • Integración de librerías
    • STL como núcleo estándar.
    • Boost, Qt, Poco, Eigen para necesidades avanzadas.
  • Patrones de diseño aplicados
    • Singleton, Factory, Observer, Strategy y RAII.
    • Permiten arquitecturas modulares, extensibles y mantenibles.

Flujo típico de ejecución

  1. Preprocesamiento: macros, inclusión de headers.
  2. Compilación: traducción a código objeto por compilador.
  3. Linking: combinación de objetos y librerías.
  4. Ejecución: gestión de memoria, construcción de objetos y ejecución de funciones.

Buenas prácticas arquitectónicas

  • Mantener módulos cohesivos y con baja dependencia.
  • Usar interfaces abstractas y polimorfismo para flexibilidad.
  • Separar lógica de presentación, negocio y persistencia (similar a MVC).
  • Evitar memoria cruda, preferir punteros inteligentes y RAII.
  • Activar warnings y analizar rendimiento en compilación.

Temarios de cursos de C++ actuales

Curso “Programación en C++ de cero con estructuras de datos y POO” (Udemy)

  • Algoritmos
  • Operadores aritméticos, lógicos y de comparación
  • Estructuras de control
  • Arreglos unidimensionales y bidimensionales
  • Funciones y métodos
  • Programación estructurada
  • Librerías
  • Manejo de archivos
  • Paso por valor y por referencia
  • Funciones especiales
  • Variables globales y locales
  • Punteros
  • Clases predefinidas (string, vector, etc.)
  • Complejidad algorítmica
  • Espacios de nombres (namespace)
  • Introducción a estructuras de datos (en curso ampliación)
  • Sobrecarga de métodos y funciones (próximamente)
  • Métodos especiales (getter, setter, toString) (próximamente)
  • Clases abstractas (próximamente)
  • Herencia (próximamente)
  • Polimorfismo (próximamente)
    Link al curso

Temario de GeeksforGeeks – Master C++ Programming

1. C++ Basics

  • Introducción, primer programa
  • Comentarios en C++

    2. Variables y tipos de datos

  • Variables, reglas de nombres
  • Tipos, rango y conversions
  • static, const, auto

    3. Entrada y salida

  • I/O básico y manipulación

    4. Operadores

  • Aritméticos, asignación, comparación
  • Operadores bitwise, precedencia y asociatividad

    5. Control de flujo

  • if, else, switch, bucles

    6. Funciones

  • Declaración y definición
  • Argumentos por defecto
  • Sobrecarga e inline

    7. Bucles (Looping) (continuación probable)

    Link al curso

Curso de C++ – CEPI-BASE (Barcelona)

  • Introducción al lenguaje C++
  • Conceptos básicos de C++
  • Sentencias de control
  • Funciones y librerías
  • Arrays, vectores y matrices
  • Estructuras y uniones
  • Punteros
  • Ficheros
  • Programación orientada a objetos
  • Constructores y destructores
  • Sobrecarga
  • Herencia y polimorfismo
  • Plantillas (templates)
  • Controles avanzados
  • Entorno gráfico en C++
    Link al curso

Curso de programación en C++ (Hotmart)

  • Introducción y entrada/salida
  • Operadores y expresiones
  • Condicionales y bucles
  • Arreglos y matrices
  • Cadenas
  • Métodos de ordenamiento y búsqueda
  • Estructuras (pilas, colas, listas, árboles)
  • Funciones
  • Punteros
  • Archivos
  • POO: clases y objetos
  • Herencia y polimorfismo
  • Plantillas (templates)
  • Eficiencia y análisis de algoritmos
  • Recursividad
  • STL (Standard Template Library)
    Link al curso

“Modern C++ Programming” – curso abierto (Modern-CPP-Programming)

  • Introducción y preparación
  • Tipos fundamentales y sistema de tipos
  • Conversiones y reglas
  • Keyword auto
  • Operadores (incluye operador <=> y comparación segura)
  • Temas avanzados de tipos (integrales, flotantes, undefined behavior)
    (Este syllabus continúa con más detalles según estándar moderno: constexpr, templates, STL, etc.)
    Link al curso

Cursos especializados y módulos adicionales

Modern C++ Features & Concurrency (Coursera)

  • Técnicas de concurrency std::thread, std::mutex
  • C++17 avanzado (if constexpr, structured bindings, noexcept)
  • Argument Deduction (CTAD)
    (parte de un specialization de Modern C++)
    Link al curso

Foundations of Modern C++ (Coursera)

  • Sintaxis moderna C++11/14/17
  • Gestión de memoria y smart pointers
  • Principios de OOP y diseño de clases eficientes
    Link al curso

Syllabus universitario (ejemplo de curso estructurado)

C++ Programming – TESU

  • Programación básica en C++
  • Arrays y punteros
  • Encapsulación, abstracción y clases
  • Sobrecarga de operadores e herencia
  • Polimorfismo y templates
  • Archivo y manejo de excepciones
    Link al syllabus

Comparación general de temas frecuentes

Fundamentos (presentes en casi todos)

  • Instalación y entorno de desarrollo
  • Primer programa y compilación
  • Tipos de datos y variables
  • Operadores y expresiones
  • Control de flujo (if, switch, loops)
  • Funciones y sobrecarga
  • Arrays y strings
  • Punteros y referencias
  • Entrada/Salida básica

Programación intermedia

  • Estructuras y uniones
  • Memoria dinámica
  • Namespaces
  • Algoritmos básicos (ordenamiento y búsqueda)
  • Recursividad

Programación avanzada

  • OOP: clases, objetos, herencia, polimorfismo
  • Plantillas (templates)
  • Excepciones y manejo de errores
  • STL – contenedores y algoritmos
  • Concurrency y threading (en cursos avanzados)
  • Plantillas modernas y técnicas de C++11/14/17+

Temas especializados

  • Eficiencia y análisis de algoritmos
  • Diseño de software y patrones
  • Concurrencia y sincronización
  • Compiladores, linking y construcción de proyectos

Recursos C++ (actualizados 2025‑2026)

Documentación y referencias esenciales

  • cppreference.com — Referencia actualizada de lenguaje y librería estándar (C++11/14/17/20/23).
  • C++ Core Guidelines — Conjunto de prácticas modernas mantenido por Bjarne Stroustrup y Herb Sutter.
  • Boost C++ Libraries (documentación) — Librerías avanzadas ampliamente usadas en proyectos reales.
    Awesome Modern C++ (repositorio de recursos) — colección de libros, guías y herramientas para C++ moderno compilada en 2025‑2026.

Tutoriales y cursos online (libres o actualizados)

En línea y gratuitos

  • LearnCpp.com — Curso en línea completo gratuito desde básico a avanzado.
  • SoloLearn – Intro to C++ — Curso interactivo introductorio.
  • C++ free learning resources — Lista de cursos y videos por nivel (principiante → avanzado) con enlaces a repositorios y playlists.

Cursos actualizados 2025‑2026

  • Curso de introducción a C++ | OpenWebinars — Introducción práctica con tipos básicos, control de flujo, punteros y funciones.
    Curso de introducción C++
  • Ruta Programador en C++ | OpenWebinars — Serie de cursos que cubren desde conceptos básicos hasta POO y diseño SOLID.
    Programador en C++ (OpenWebinars)
  • Máster de Programación Esencial de C++ (Udemy) — Curso completo con 22 lecciones desde nivel principiante a avanzado (opciones con cupón disponible en 2025).
    Máster en C++ (Udemy)
  • C++ gratis con certificado (Formencia) — Recursos gratuitos con opción de certificado en múltiples idiomas.
    Programación con C++ (Formencia)

Cursos y formaciones presenciales o semipresenciales

  • Lenguaje C++ (OO) – UTN BA — Curso con inicio en marzo 2026 sobre paradigmas y programación orientada a objetos con C++.
    Curso UTN Lenguaje C++
  • Modern C++ Software Design (HLRS)
    • Intermedio: marzo/julio 2025
    • Avanzado: mayo/noviembre 2025
      Cursos intensivos sobre diseño de software con C++ moderno, templates y buenas prácticas.
      HLRS C++ Software Design

Guías de aprendizaje y listas recomendadas

  • Roadmap C++ (online) — rutas de aprendizaje desde básico hasta avanzado que incluyen STL, concurrencia y diseño moderno.
  • GitHub gist “Resources for C++ beginners” — colección de videos, libros y guías seleccionadas por la comunidad y actualizada en 2025.
    Resources for C++ beginners

Temas y recursos complementarios (2025‑2026)

  • RAII y manejo de recursos — listas de cursos y charlas enfocadas en RAII para escribir código moderno seguro.
  • Concurrencia y multithread (C++17/20) — cursos especializados en manejo de threads, mutexes y programación segura.
    (según agregadores de cursos como Class Central para 2026).
    Class Central – RAII y multithread

Comunidades y soporte

  • Foros y subreddits de C++ — hilos activos en 2025‑2026 donde la comunidad discute proyectos, comparte cursos y recursos.

Resumen rápido por nivel

Principiante

  • LearnCpp.com
  • SoloLearn – Intro to C++
  • OpenWebinars – Curso de introducción

Intermedio

  • OpenWebinars – Estructuras de control & POO
  • Repositorios de ejercicios y playlists de YouTube
  • RAII y prácticas modernas

Avanzado

  • OpenWebinars – SOLID y diseño de software
  • Cursos HLRS (intermedio/avanzado)
  • Concurrencia y patrones de diseño

Tips para aprovechar recursos

  • Combinar documentación oficial (cppreference, C++ Core Guidelines) con cursos prácticos.
  • Practicar con exercises y proyectos reales compartidos en comunidades como Reddit.
  • Actualizarse constantemente, porque C++ sigue evolucionando con nuevas normas y prácticas.

omnivore cpp

type: list
name: "Notas con #cpp en Omnivore"
order:
  - property: date_saved
    direction: desc
columns:
  - file.name
  - date_saved
filters:
  and:
    - file.inFolder("Omnivore")
    - file.hasTag("cpp", "CPP")
views:
  - type: table
    name: Table
    sort:
      - property: file.mtime
        direction: DESC