C++

¿Qué es C++?

C++ es un lenguaje de programación de alto y bajo nivel, compilado, fuertemente tipado y de alto rendimiento. Extiende C agregando soporte para Programación Orientada a Objetos y es ampliamente usado en sistemas operativos, videojuegos, motores gráficos y software de alto rendimiento.

Hola Mundo en C++

#include <iostream>

int main() {
    std::cout << "Hola Mundo!" << std::endl;
    return 0;
}
$ g++ main.cpp -o main
$ ./main
Hola Mundo!
Probarlo >>

Componentes del ecosistema

  • Compiladores (GCC / Clang / MSVC): traducen el código fuente directamente a lenguaje máquina optimizado para el sistema operativo.
  • STL (Standard Template Library): biblioteca estándar que provee estructuras de datos (vectores, listas) y algoritmos genéricos.
  • Sistemas de Construcción (CMake / Make): herramientas para automatizar la compilación y gestión de proyectos complejos.

Tipos de datos principales

  • Enteros: int, short, long, long long.
  • Decimales: float (32 bits), double (64 bits).
  • Carácter: char (entre comillas simples 'a').
  • Booleanos: bool (valores true o false).
  • Cadenas de texto: std::string (requiere #include <string>).

Variables

Las variables en C++ requieren declarar explícitamente su tipo de dato en memoria antes de utilizarlas. Se pueden definir constantes fijas mediante const o constexpr. Con sizeof vemos cuántos bytes ocupa cada tipo.

Declaración e inicialización

int edad = 26;
const double PI = 3.14159;
auto texto = "Hola Mundo";  // Deducción automática de tipo (C++11)

std::cout << sizeof(int) << " " << sizeof(double) << " " << sizeof(char);
$ g++ main.cpp -o main
$ ./main
4 8 1

Como el tipo es fijo, si le damos a una variable un valor que no corresponde el programa ni siquiera llega a ejecutarse: el compilador nos frena antes.

Error de compilación por tipo incorrecto

#include <iostream>

int main() {
    int edad = "veinte";
}
$ g++ main.cpp -o main
main.cpp: In function 'int main()':
main.cpp:4:16: error: invalid conversion from 'const char*' to 'int' [-fpermissive]
    4 |     int edad = "veinte";
      |                ^~~~~~~~

Tip: el error dice main.cpp:4:16, o sea archivo, línea 4 y columna 16. Para comentar usá // mensaje (una línea) o /* mensaje */ (bloque).

Operadores

C++ provee operadores aritméticos, de comparación y lógicos altamente eficientes para operaciones numéricas y condicionales. Hay que tener cuidado con la división: entre dos enteros, el resultado también es entero.

Operadores aritméticos, de comparación y lógicos

int suma = 5 + 3;                  // Aritméticos: +  -  *  /  %
bool mayor = edad >= 18;           // Comparación: ==  !=  >  <  >=  <=
bool puede = mayor && activo;      // Lógicos: && (y)  || (o)  ! (no)

División entera y decimal

std::cout << 7 / 2 << std::endl;     // los dos son int
std::cout << 7.0 / 2 << std::endl;   // uno es double
std::cout << 7 % 2 << std::endl;     // resto de la división
std::cout << (5 > 3) << std::endl;   // un bool se imprime como 1 o 0
$ g++ main.cpp -o main
$ ./main
3
3.5
1
1

Condicionales

Estructuras de control para tomar decisiones durante la ejecución del programa mediante evaluadores if, else if, else y la sentencia switch.

Estructura if / else if / else

int edad = 15;

if (edad >= 18) {
    std::cout << "Mayor de edad" << std::endl;
} else if (edad >= 13) {
    std::cout << "Adolescente" << std::endl;
} else {
    std::cout << "Niño" << std::endl;
}
$ g++ main.cpp -o main
$ ./main
Adolescente

Estructura switch

int dia = 2;

switch (dia) {
    case 1:
        std::cout << "Lunes";
        break;
    case 2:
        std::cout << "Martes";
        break;
    default:
        std::cout << "Otro día";
}
$ g++ main.cpp -o main
$ ./main
Martes

Tip: si te olvidás el break, el switch sigue ejecutando los case de abajo.

Bucles e iteraciones

Repiten bloques de código mientras se cumpla una condición dada. Incluye bucles tradicionales for, while y el bucle basado en rangos.

for, while y range-based for

std::vector<std::string> nombres = {"Ana", "Leo"};

for (int i = 0; i < 3; i++) {
    std::cout << i << std::endl;
}

int contador = 0;
while (contador < 10) {
    contador++;
}

for (const auto& nombre : nombres) {
    std::cout << nombre << std::endl;
}
$ g++ main.cpp -o main
$ ./main
0
1
2
Ana
Leo

Tip: usá break para detener un bucle y continue para omitir el resto de la iteración actual.

Funciones

Bloques reutilizables de código que deben especificar el tipo de dato que retornan (o void si no retornan nada) y el tipo de sus parámetros.

Declarar y llamar funciones

int sumar(int a, int b) {
    return a + b;
}

void saludar(std::string nombre = "Visitante") {
    std::cout << "Hola " << nombre << std::endl;
}

int main() {
    std::cout << sumar(4, 6) << std::endl;
    saludar("Ana");
    saludar();
    return 0;
}
$ g++ main.cpp -o main
$ ./main
10
Hola Ana
Hola Visitante

Tip: el compilador lee de arriba hacia abajo, por eso las funciones tienen que estar escritas (o declaradas) antes del main que las usa.

Punteros y Referencias

Una de las características más potentes de C++ es el acceso directo a la memoria mediante punteros (almacenan direcciones de memoria) y referencias (alias de variables existentes). Con & obtenemos la dirección de una variable y con * el valor que hay en esa dirección.

Uso de referencias y punteros

int numero = 10;
int& ref = numero;   // Referencia a 'numero'
int* ptr = &numero;  // Puntero que guarda la dirección de 'numero'

std::cout << &numero << std::endl;
std::cout << ptr << std::endl;

*ptr = 20;           // Modifica 'numero' a través del puntero
std::cout << numero << " " << ref << std::endl;
$ g++ main.cpp -o main
$ ./main
0x7ffd5e8a3b4c
0x7ffd5e8a3b4c
20 20
DirecciónVariableValor
0x7ffd5e8a3b4cnumero / ref20
0x7ffd5e8a3b50ptr0x7ffd5e8a3b4c

Tip: las direcciones cambian cada vez que ejecutás el programa, lo importante es que ptr guarda la misma dirección que tiene numero.

Estructuras de Datos y STL

La Biblioteca Estándar (STL) proporciona contenedores genéricos y eficientes para gestionar colecciones de datos:

Vectores (std::vector)

Arreglos dinámicos que cambian de tamaño automáticamente.

Mapas (std::map)

Estructuras asociativas organizadas en pares clave-valor.

Conjuntos (std::set)

Colecciones ordenadas que solo permiten elementos únicos.

Ejemplo de std::vector, std::map y std::set

#include <vector>
#include <map>
#include <set>

std::vector<std::string> alumnos = {"Ana", "Leo"};
alumnos.push_back("Maria");
std::cout << alumnos.size() << std::endl;

std::map<std::string, int> edades;
edades["Ana"] = 17;
std::cout << edades["Ana"] << std::endl;

std::set<int> numeros = {5, 1, 3, 1};
for (int n : numeros) {
    std::cout << n << " ";
}
$ g++ main.cpp -o main
$ ./main
3
17
1 3 5

Tip: el std::set ordenó los números y descartó el 1 repetido por su cuenta.

Programación Orientada a Objetos

Permite organizar el código mediante clases, objetos, modificadores de acceso (public, private, protected), constructores y herencia. Con virtual dejamos que una clase hija reemplace un método del padre.

Clases, objetos y herencia

class Animal {
protected:
    std::string nombre;
public:
    Animal(std::string n) : nombre(n) {}
    virtual std::string hacerSonido() { return "..."; }
};

class Perro : public Animal {
public:
    Perro(std::string n) : Animal(n) {}
    std::string hacerSonido() override { return "¡Guau!"; }
};

Perro miPerro("Firulais");
std::cout << miPerro.hacerSonido() << std::endl;
$ g++ main.cpp -o main
$ ./main
¡Guau!

Tip: en C++ la clase termina con punto y coma después de la llave }; y es un error muy común olvidárselo.

Manejo de Excepciones

Control de errores en tiempo de ejecución utilizando los bloques try, catch y la palabra clave throw. Si nadie atrapa la excepción, el programa se cierra de golpe.

try, catch y throw

#include <stdexcept>

int divisor = 0;

try {
    if (divisor == 0) {
        throw std::runtime_error("No se puede dividir por cero");
    }
    int resultado = 10 / divisor;
} catch (const std::exception& e) {
    std::cout << "Error: " << e.what() << std::endl;
}
$ g++ main.cpp -o main
$ ./main
Error: No se puede dividir por cero

El mismo throw sin try/catch

$ g++ main.cpp -o main
$ ./main
terminate called after throwing an instance of 'std::runtime_error'
  what():  No se puede dividir por cero
Aborted (core dumped)