CORE
1. Gestión de Memoria y Punteros
C++ da control total sobre la memoria. Entender el Stack (pila) y el Heap (montón) es crítico.
Stack vs Heap
Variables locales van al Stack (rápido, automático). Memoria dinámica (new) va al Heap (manual, persistente).
Punteros y Referencias
int x = 10;
int* ptr = &x; // Puntero: almacena dirección
int& ref = x; // Referencia: alias (no puede ser null)
*ptr = 20; // Desreferencia: modifica x
Smart Pointers (RAII)
En C++ Moderno, evitamos new/delete crudos. Usamos RAII (Resource Acquisition Is Initialization).
std::unique_ptr: Propiedad exclusiva. Se borra al salir del ámbito.std::shared_ptr: Propiedad compartida (conteo de referencias).
// Moderno y seguro
auto uPtr = std::make_unique<Data>();
OOP
2. Clases y Polimorfismo
Clases y Encapsulamiento
Separación de interfaz (.h) e implementación (.cpp). Control de acceso: public, private, protected.
Herencia y Virtualidad
Para lograr polimorfismo en tiempo de ejecución, usamos funciones virtuales. Esto crea una V-Table (tabla de punteros a funciones).
class Base {
public:
virtual void draw() const = 0; // Pura virtual
virtual ~Base() = default; // Destructor virtual vital
};
Sobrecarga de Operadores
Permite definir comportamiento para operadores como +, ==, << en tipos personalizados.
STL
3. Templates y la STL
La Standard Template Library provee contenedores y algoritmos genéricos de alto rendimiento.
Contenedores Secuenciales
std::vector: Array dinámico contiguo. O(1) acceso, O(1) push back amortizado. Default choice.std::list: Lista doblemente enlazada.std::deque: Cola de doble extremo.
Contenedores Asociativos
std::map: Árbol Rojo-Negro (Ordenado, O(log n)).std::unordered_map: Tabla Hash (Desordenado, O(1)).
Algoritmos
std::vector<int> v = {4, 1, 3, 2};
std::sort(v.begin(), v.end());
// Usa IntroSort (Quick + Heap + Insertion)
MODERN
4. C++11 / 14 / 17 / 20
Características que transformaron el lenguaje.
Semántica de Movimiento (Move Semantics)
Evita copias costosas transfiriendo recursos de objetos temporales (r-values). Uso de std::move y constructores de movimiento.
Lambdas
Funciones anónimas in-situ. Capturan variables del entorno.
auto add = [](int a, int b) { return a + b; };
std::for_each(v.begin(), v.end(), [](int& n){ n *= 2; });
Multithreading
Librería <thread>, std::async, std::mutex y std::atomic para concurrencia segura.
Level 1: Novice (Syntax & Logic)
1. Hola Mundo & I/O Novice
Lee nombre y edad, imprime saludo.
#include <iostream>
#include <string>
int main() {
std::string name;
int age;
std::cin >> name >> age;
std::cout << "Hello " << name << ", age " << age << "\n";
return 0;
}
2. Suma de Array (Punteros) Novice
Itera un array usando aritmética de punteros.
int sum(int* arr, int size) {
int s = 0;
for(int* p = arr; p < arr + size; ++p) {
s += *p;
}
return s;
}
3. Referencias Swap Novice
void swap(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}
4. Factorial Recursivo Novice
unsigned long long factorial(int n) {
return (n <= 1) ? 1 : n * factorial(n - 1);
}
5. String Palíndromo Novice
bool isPalindrome(const std::string& s) {
int l = 0, r = s.length() - 1;
while (l < r) {
if (s[l++] != s[r--]) return false;
}
return true;
}
6. Max en Vector Novice
#include <vector>
#include <algorithm>
int getMax(const std::vector<int>& v) {
return *std::max_element(v.begin(), v.end());
}
7. Estructura Simple Novice
struct Point { int x, y; };
Point add(Point a, Point b) {
return {a.x + b.x, a.y + b.y};
}
8. Bucle Foreach (C++11) Novice
void printAll(const std::vector<int>& v) {
for (const auto& elem : v) {
std::cout << elem << " ";
}
}
9. Lectura de Archivo Novice
#include <fstream>
void readFile() {
std::ifstream f("data.txt");
std::string line;
while (std::getline(f, line)) { /*...*/ }
}
10. Enum Class Novice
enum class Color { Red, Green, Blue };
void pick(Color c) {
if (c == Color::Red) { /*...*/ }
}
Level 2: Intermediate (OOP & STL)
11. Clase Vector Personalizada Inter
Implementa Regla de los 3 (Destructor, Copy Ctor, Copy Assign).
class MyVector {
int* data; size_t size;
public:
MyVector(size_t s) : size(s), data(new int[s]) {}
~MyVector() { delete[] data; } // RAII
// Copy Ctor...
};
12. Herencia y Virtualidad Inter
class Shape {
public:
virtual double area() const = 0;
virtual ~Shape() {}
};
class Circle : public Shape {
double r;
public:
Circle(double r) : r(r) {}
double area() const override { return 3.14 * r * r; }
};
13. Map Frecuencias Inter
#include <map>
std::map<std::string, int> countWords(const std::vector<std::string>& words) {
std::map<std::string, int> counts;
for (const auto& w : words) counts[w]++;
return counts;
}
14. Sobrecarga Operador + Inter
struct Vec2 { float x, y; };
Vec2 operator+(const Vec2& a, const Vec2& b) {
return {a.x + b.x, a.y + b.y};
}
15. Template Función (Min) Inter
template <typename T>
T myMin(T a, T b) {
return (a < b) ? a : b;
}
16. Lambda Sort Inter
std::sort(v.begin(), v.end(), [](int a, int b) {
return a > b; // Descendente
});
17. Exception Handling Inter
double divide(double a, double b) {
if (b == 0) throw std::runtime_error("Div by zero");
return a / b;
}
18. Unique Ptr Factory Inter
std::unique_ptr<Widget> createWidget() {
return std::make_unique<Widget>();
}
19. Static Singleton Inter
class Singleton {
public:
static Singleton& get() {
static Singleton instance;
return instance;
}
Singleton(const Singleton&) = delete;
private:
Singleton() {}
};
20. File Stream RAII Inter
Lectura segura con fstream.
Level 3: Expert (Modern & Systems)
21. Move Semantics (Regla de los 5) Expert
Implementar Move Constructor y Move Assignment para evitar copias profundas.
class Buffer {
// ...
Buffer(Buffer&& other) noexcept : data(other.data) {
other.data = nullptr;
}
};
22. Hilos (std::thread) Expert
void worker(int id) { /*...*/ }
int main() {
std::vector<std::thread> threads;
for(int i=0; i<4; ++i) threads.emplace_back(worker, i);
for(auto& t : threads) t.join();
}
23. Mutex & Lock Guard Expert
std::mutex mtx;
void safeIncrement(int& counter) {
std::lock_guard<std::mutex> lock(mtx);
counter++;
}
24. Variadic Templates Expert
template<typename... Args>
void printAll(Args... args) {
(std::cout << ... << args) << '\n'; // Fold expression C++17
}
25. SFINAE / Concepts (C++20) Expert
template<typename T>
requires std::integral<T>
T add(T a, T b) { return a + b; }
26. Custom Allocator (Arena) Expert
Implementar un asignador de memoria simple para contenedores STL.
27. Type Erasure (std::any) Expert
Uso de void* moderno o herencia interna para guardar cualquier tipo.
28. Corrutinas (C++20) Expert
Uso de co_await y co_yield para generadores asíncronos.
29. Perfect Forwarding Expert
template<typename T>
void wrapper(T&& arg) {
func(std::forward<T>(arg));
}
30. SIMD Intrinsics Expert
Uso básico de AVX/SSE para sumar arrays en paralelo.