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(valorestrueofalse). - 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 = № // 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ón | Variable | Valor |
|---|---|---|
| 0x7ffd5e8a3b4c | numero / ref | 20 |
| 0x7ffd5e8a3b50 | ptr | 0x7ffd5e8a3b4c |
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)