C++

⚙️ C++: Poder, rendimiento y control total

Guía extensa y profunda — desde los fundamentos de la programación hasta C++17/20/23, sistemas embebidos, juegos y software de alto rendimiento.

🔷 Estándar ISO C++ | Compilación nativa | Bjarne Stroustrup

📖 Tabla de contenidos

• 1. ¿Qué es C++?
• 2. Historia y evolución (C++98 a C++23)
• 3. Sintaxis básica y estructura
• 4. Variables, tipos y constantes
• 5. Flujo de control
• 6. Funciones y sobrecarga
• 7. Punteros y referencias
• 8. Gestión dinámica de memoria
• 9. Programación Orientada a Objetos
• 10. STL (contenedores, algoritmos)
• 11. C++ moderno (C++11 en adelante)
• 12. Manejo de excepciones
• 13. Temas avanzados: templates, move semantics
• 14. Herramientas y ecosistema
• 15. Buenas prácticas y estándares

🚀 1. ¿Qué es C++?

C++ es un lenguaje de programación compilado, de propósito general, que combina características de alto y bajo nivel. Creado por Bjarne Stroustrup en 1985 como extensión de C (C with Classes). Soporta programación procedural, orientada a objetos, genérica (templates) y funcional. Es la base de sistemas operativos, motores de videojuegos (Unreal Engine), bases de datos, compiladores, software financiero, e incluso sistemas embebidos. Su lema: “no pagas por lo que no usas” → control absoluto sobre el hardware.

✨ Rendimiento extremo: C++ permite manipular memoria directamente, lo que lo hace ideal para aplicaciones en tiempo real y de alto rendimiento.

📜 2. Evolución de C++: desde C++98 hasta C++23

Estandarizado por ISO en 1998 (C++98), el lenguaje ha evolucionado enormemente. C++11 trajo auto, lambdas, move semantics, punteros inteligentes. C++14, C++17 mejoraron la librería estándar. C++20 añadió corrutinas, conceptos, rangos y módulos. C++23 sigue modernizando el lenguaje. Hoy C++ es más seguro, expresivo y eficiente.

Versión	Aportaciones clave
C++98/03	STL inicial, excepciones, RTTI
C++11	Move semantics, lambdas, nullptr, shared_ptr, hilos nativos
C++14	Lambdas genéricas, literales binarios, make_unique
C++17	Optional, variant, parallel algorithms, if constexpr
C++20	Conceptos, corrutinas, rangos, std::span, módulos
C++23	Estándar más pulido, std::expected, std::mdspan

🔔 Recomendación: usar al menos C++17/20 en proyectos nuevos para mayor seguridad y expresividad.

✏️ 3. Sintaxis fundamental y "Hola Mundo"

Un programa en C++ comienza con la función main. Se usan cabeceras (#include) y el espacio de nombres std para la biblioteca estándar.

#include <iostream>
// Comentario de línea
/* comentario
   multilínea */
int main() {
    std::cout << "¡Hola, C++ en Blogger!" << std::endl;
    return 0;
}

Compilación típica: g++ -std=c++20 programa.cpp -o programa

📦 4. Variables, tipos de datos y constantes

Tipos fundamentales: int, char, float, double, bool, void. Además modificadores: short, long, signed, unsigned. C++11 introdujo auto y tipos de deducción.

#include <iostream>
int main() {
    int edad = 28;
    double pi = 3.1415926535;
    char letra = 'C';
    bool esEstudiante = true;
    auto mensaje = "C++ moderno";  // const char*
    const int DIAS_SEMANA = 7;
    std::cout << "Edad: " << edad << ", PI ≈ " << pi;
    return 0;
}

💡 constexpr: evaluado en tiempo de compilación, ideal para constantes de rendimiento.

🔄 5. Estructuras de control

Condicionales (if, else if, switch) y bucles (for, while, do-while). También el range-based for desde C++11.

#include <iostream>
#include <vector>
int main() {
    int nota = 85;
    if (nota >= 90) std::cout << "Sobresaliente";
    else if (nota >= 70) std::cout << "Notable";
    else std::cout << "Mejorable";

    // for each moderno
    std::vector<int> numeros = {1,2,3,4,5};
    for (int n : numeros) {
        std::cout << n << " ";
    }
    return 0;
}

⚙️ 6. Funciones: parámetros, sobrecarga e inline

C++ permite funciones con sobrecarga (mismo nombre distintos parámetros), valores por defecto, y plantillas. El paso puede ser por valor, referencia o puntero.

int suma(int a, int b) { return a + b; }
double suma(double a, double b) { return a + b; }  // Sobrecarga
void saludar(const std::string& nombre) {
    std::cout << "Hola " << nombre;
}
int main() {
    std::cout << suma(3,4) << "\n";
    saludar("Ana");
    return 0;
}

Funciones inline sugieren al compilador evitar llamadas para optimización.

📍 7. Punteros y referencias (control directo)

Los punteros almacenan direcciones de memoria; las referencias son alias de variables. C++ moderno recomienda usar referencias y punteros inteligentes siempre que sea posible.

int x = 10;
int* ptr = &x;      // puntero a x
int& ref = x;       // referencia
*ptr = 20;          // modifica x
ref = 30;           // también modifica x
std::cout << x;     // 30

// Puntero nulo: nullptr (C++11)
int* p = nullptr;
if(p == nullptr) { /* seguro */ }

⚠️ Los punteros no inicializados causan comportamiento indefinido; usar siempre inicialización.

🧠 8. Gestión dinámica de memoria: new/delete vs smart pointers

Con new y delete se asigna memoria en el heap. Pero C++11 introduce punteros inteligentes (unique_ptr, shared_ptr, weak_ptr) que automatizan la liberación.

#include <memory>
// Manejo manual (no recomendado)
int* arr = new int[10];
delete[] arr;

// Moderno: unique_ptr
std::unique_ptr<int> p1 = std::make_unique<int>(42);
auto p2 = std::make_shared<double>(3.14);
// no necesita delete, se libera automáticamente

📌 Prefiera siempre std::make_unique y std::make_shared; evite fugas de memoria.

🧬 9. Programación Orientada a Objetos en C++

Clases, herencia (pública, privada, protegida), polimorfismo (funciones virtuales), encapsulación (public/private/protected). Métodos especiales: constructor, destructor, copia/movimiento.

class Animal {
protected:
    std::string nombre;
public:
    Animal(const std::string& n) : nombre(n) {}
    virtual void sonido() const { std::cout << "...\n"; }
    virtual ~Animal() = default;
};

class Perro : public Animal {
public:
    Perro(const std::string& n) : Animal(n) {}
    void sonido() const override {
        std::cout << nombre << " dice: Guau!\n";
    }
};

int main() {
    std::unique_ptr<Animal> mascota = std::make_unique<Perro>("Rex");
    mascota->sonido();
}

📚 10. Biblioteca Estándar (STL): contenedores y algoritmos

Contenedores: vector, list, deque, map, unordered_map, set. Algoritmos: sort, find, accumulate, transform. Streams: <iostream>, <fstream>.

#include <vector>
#include <algorithm>
#include <iostream>
int main() {
    std::vector<int> v = {5, 2, 8, 1, 9};
    std::sort(v.begin(), v.end());
    for (int i : v) std::cout << i << " ";
    // 1 2 5 8 9
    auto it = std::find(v.begin(), v.end(), 5);
    if(it != v.end()) std::cout << "\nEncontrado 5";
}

✨ 11. C++ moderno: características clave (C++11/14/17/20)

• auto: deducción de tipo automática.
• Lambdas: funciones anónimas: [&](int x){ return x*x; }.
• Move semantics: transferencia de recursos con std::move.
• Concurrencia: std::thread, std::async, std::mutex.
• Range-based for, structured bindings (C++17).
• Conceptos (C++20): restricciones para templates.

// Ejemplo lambda + auto
auto cuadrado = [](auto x) { return x * x; };
std::cout << cuadrado(5) << ", " << cuadrado(2.5);

// structured binding C++17
std::map<std::string, int> datos = {{"a",1}};
for (const auto& [clave, valor] : datos) {
    std::cout << clave << ":" << valor;
}

⚠️ 12. Manejo de excepciones

Se usan try, catch, throw. Permite manejar errores de forma estructurada.

#include <stdexcept>
double division(double a, double b) {
    if (b == 0) throw std::runtime_error("División por cero");
    return a / b;
}
int main() {
    try {
        double res = division(10, 0);
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    return 0;
}

🧩 13. Temas avanzados: Templates, metaprogramación y move semantics

Los templates permiten código genérico (como std::vector<T>). La metaprogramación con constexpr, if constexpr permite evaluar en tiempo de compilación. Move semantics mejora el rendimiento en copias pesadas.

template <typename T>
T maximo(T a, T b) { return (a > b) ? a : b; }

// variadic templates (C++11)
template<typename... Args>
void imprimir(Args... args) {
    (std::cout << ... << args) << '\n'; // fold expression C++17
}
int main() {
    std::cout << maximo(3,7) << std::endl;
    imprimir(1,2.5,"texto");
}

🛠️ 14. Herramientas fundamentales del ecosistema C++

• Compiladores: GCC (g++), Clang, MSVC (Visual Studio).
• Build systems: CMake, Meson, Make.
• Gestor de paquetes: Conan, vcpkg.
• Depuración: GDB, LLDB, Visual Studio Debugger.
• Perfilado: Valgrind, perf, Intel VTune.
• Análisis estático: Clang-Tidy, Cppcheck.

CMake + Conan es una combinación moderna para gestionar dependencias y compilación multiplataforma.

✅ 15. Buenas prácticas y estándares (C++ Core Guidelines)

Las C++ Core Guidelines (Bjarne Stroustrup & Herb Sutter) ofrecen reglas para escribir código seguro y moderno. Principios clave:

• Preferir std::array o std::vector sobre arreglos estilo C.
• Usar nullptr en lugar de NULL o 0.
• Evitar new y delete explícitos; usar RAII y punteros inteligentes.
• Declarar variables lo más locales posible (int x{5}).
• Usar const y constexpr siempre que sea posible.
• Escribir código legible y documentado, con nombres descriptivos.

📘 Regla de oro: "No hay código perfecto, pero siempre se puede mejorar con buenas prácticas".

⬆ Volver al inicio

🎯 Conclusión: C++ sigue siendo una fuerza imparable en desarrollo de software de alto rendimiento, juegos, sistemas embebidos y finanzas. Aprender C++ moderno te dará una base sólida en gestión de recursos, algoritmos y arquitectura de software. Explora recursos como cppreference.com, "C++ Primer" y ejercita con pequeños proyectos.

📘 Guía extensa de C++ para Blogger — Contenido actualizado 2026 | Ejemplos compatibles con C++17/20
🔧 Necesitarás un compilador (GCC/Clang) para probar los ejemplos.