Hoja de Trucos de C++
Última actualización
Hola Mundo y estructura del programa
La ejecución empieza en main, que devuelve un int.
| Elemento | Código |
|---|---|
| Incluir una cabecera | #include <iostream> |
| Punto de entrada | int main() { ... } |
| Imprimir una línea | std::cout << "Hello, World!" << std::endl; |
| Leer entrada | std::cin >> x; |
| Usar el espacio de nombres std | using namespace std; |
| Devolver éxito | return 0; |
| Comentarios | // line y /* block */ |
Tipos de datos
| Tipo | Descripción |
|---|---|
int | Entero (normalmente 32 bits) |
long / long long | Enteros más anchos |
float / double | Números de punto flotante |
char | Un solo byte / carácter |
bool | true o false |
std::string | Texto dinámico de <string> |
auto | El compilador infiere el tipo |
std::size_t | Tipo sin signo para tamaños e índices |
Variables y referencias
Las referencias son alias; los punteros almacenan direcciones.
| Operación | Sintaxis |
|---|---|
| Declarar e inicializar | int x = 5; |
| Inicialización con llaves | int x{5}; |
| Constante | const double PI = 3.14159; |
| Constante en tiempo de compilación | constexpr int N = 10; |
| Referencia (alias) | int &r = x; |
| Puntero | int *p = &x; |
| Desreferenciar un puntero | *p = 10; |
| Inferencia de tipo | auto y = 3.14; |
Control de flujo
| Sentencia | Sintaxis |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Switch | switch (n) { case 1: ...; break; default: ...; } |
| Bucle while | while (i < n) { ... } |
| Bucle do-while | do { ... } while (i < n); |
| Bucle for | for (int i = 0; i < n; i++) { ... } |
| For basado en rango | for (auto x : vec) { ... } |
| For basado en rango por referencia | for (auto &x : vec) { ... } |
| Break / continue | break; sale de un bucle, continue; salta a la siguiente iteración |
Funciones
| Operación | Sintaxis |
|---|---|
| Definir una función | int add(int a, int b) { return a + b; } |
| Sin valor de retorno | void greet() { ... } |
| Argumentos por defecto | int pow(int b, int e = 2) { ... } |
| Paso por referencia | void inc(int &x) { x++; } |
| Referencia constante (sin copia) | void print(const std::string &s) { ... } |
| Sobrecarga | int max(int a, int b); y double max(double a, double b); |
| Lambda | auto f = [](int x) { return x * 2; }; |
| Lambda con captura | auto g = [n](int x) { return x + n; }; |
Clases y POO
| Operación | Sintaxis |
|---|---|
| Definir una clase | class Dog { ... }; |
| Especificadores de acceso | public:, private:, protected: |
| Variable miembro | std::string name; |
| Constructor | Dog(std::string n) : name(n) {} |
| Destructor | ~Dog() { ... } |
| Función miembro | void bark() { ... } |
| Crear un objeto | Dog d("Rex"); |
| Herencia | class Puppy : public Dog { ... }; |
| Función virtual | virtual void speak(); |
Contenedores STL
Contenedores comunes de la biblioteca estándar.
| Contenedor | Uso y ejemplo |
|---|---|
std::vector<int> | Array dinámico: v.push_back(1); v.size(); |
std::string | Texto: s += "!"; s.length(); |
std::array<int, 3> | Array de tamaño fijo con información de límites |
std::map<K, V> | Clave-valor ordenado: m["a"] = 1; |
std::unordered_map<K, V> | Tabla hash (búsqueda más rápida, sin orden) |
std::set<T> | Valores únicos ordenados: s.insert(5); |
std::pair<A, B> | Dos valores: make_pair(1, "x") |
std::queue / std::stack | Adaptadores de cola FIFO / pila LIFO |
Algoritmos e iteradores STL
De <algorithm>; la mayoría toma un rango de iteradores begin/end.
| Operación | Sintaxis |
|---|---|
| Iteradores begin / end | v.begin(), v.end() |
| Ordenar | std::sort(v.begin(), v.end()); |
| Ordenar de forma descendente | std::sort(v.begin(), v.end(), std::greater<int>()); |
| Encontrar un valor | auto it = std::find(v.begin(), v.end(), 5); |
| Contar coincidencias | std::count(v.begin(), v.end(), 5); |
| Elemento mínimo / máximo | std::max_element(v.begin(), v.end()); |
| Sumar un rango | std::accumulate(v.begin(), v.end(), 0); |
| Transformar cada elemento | std::transform(v.begin(), v.end(), v.begin(), fn); |
Punteros inteligentes y C++ moderno
Prefiere los punteros inteligentes a los new/delete crudos para una limpieza automática.
| Característica | Sintaxis |
|---|---|
| Propiedad única | auto p = std::make_unique<Dog>("Rex"); |
| Propiedad compartida | auto p = std::make_shared<Dog>("Rex"); |
| Referencia sin propiedad | std::weak_ptr<Dog> w = p; |
| Semántica de movimiento | auto v2 = std::move(v1); |
| Nullptr | int *p = nullptr; |
| Enlaces estructurados | auto [key, val] = *it; |
| Valor opcional | std::optional<int> maybe; |
| Plantillas | template <typename T> T add(T a, T b) { return a + b; } |
La sintaxis, los contenedores STL y las características modernas de C++ que más usas, en una sola página. Esta hoja de trucos de C++ es una referencia rápida para escribir C++: los tipos de datos, las referencias, las clases, los contenedores y algoritmos de la biblioteca estándar y los punteros inteligentes que reemplazan a los new/delete crudos.
Todo lo que hay aquí es C++ estándar (C++11 y posteriores) y se compila con g++ o clang++. Copia lo que necesites o prueba cualquier fragmento en vivo en el playground de C++, sin instalar ningún compilador.
Preguntas frecuentes sobre la hoja de trucos de C++
¿Esta hoja de trucos de C++ es gratis?
Sí. Esta hoja de trucos de C++ es completamente gratuita, sin necesidad de registrarse. Guárdala en favoritos y vuelve cuando necesites consultar la sintaxis, un contenedor de la STL o un puntero inteligente.
¿Cuál es la diferencia entre un puntero y una referencia en C++?
Un puntero es una variable que almacena una dirección; puede ser nulo, reasignarse para apuntar a otro lugar y lo desreferencias con
*p. Una referencia (int &r = x) es un alias de una variable existente: debe enlazarse al declararla, nunca puede ser nula ni reenlazarse, y se usa como si fuera la variable misma. Usa referencias para parámetros de paso por referencia más limpios y punteros cuando necesites una indirección opcional o reasignable.¿Debería usar new/delete o punteros inteligentes?
Prefiere los punteros inteligentes.
std::unique_ptr y std::shared_ptr (a través de make_unique/make_shared) liberan su memoria automáticamente cuando salen de ámbito, lo cual evita las fugas y las dobles liberaciones que conlleva el new/delete manual. Recurre a los new/delete crudos solo en código de bajo nivel que tenga una razón específica.¿Puedo practicar C++ en línea?
Sí. Abre el playground de C++ para compilar y ejecutar cualquier fragmento de esta hoja de trucos en tu navegador, sin instalar ningún compilador. Cuando quieras estructura, el curso interactivo y gratuito de C++ de Coddy te lleva paso a paso desde las variables y los bucles hasta las clases y la STL.
¿Esta hoja de trucos es buena para principiantes?
Sí. Está organizada desde los componentes básicos más comunes (tipos, control de flujo, funciones) hasta los avanzados (la STL y los punteros inteligentes), de modo que puedes usar las secciones de arriba desde el primer día e ir avanzando hacia el resto.
Recursos relacionados
Más hojas de referencia
