10 errores de principiantes en C++: cómo no romper el código

Por qué C++ rompe incluso a los experimentados, y a los principiantes aún más

C++ es un lenguaje despiadado. Te da control total sobre la memoria, pero también exige una disciplina absoluta. Si estás empezando a aprender C++, seguramente ya te has encontrado con que el programa compila, pero falla con un error, o (lo que es peor) funciona incorrectamente sin ningún error. No es tu culpa, es la naturaleza del lenguaje. Pero podemos ayudarte a evitar los errores más comunes en los que todos los principiantes tropiezan.

En este artículo analizaremos 10 errores críticos al aprender C++ que convierten el código en una mezcla infernal de fugas de memoria y comportamiento indefinido. ¡Allá vamos!

1. Olvidaste liberar memoria: la fuga clásica

El error más popular de los principiantes en C++ es asignar memoria dinámica con new y olvidar el delete. El programa consume RAM como una aspiradora, y ni siquiera te das cuenta.

Ejemplo incorrecto:

int* ptr = new int(42);\n// ... mucho código ...\n// Olvidaste: delete ptr;

Resultado: fuga de memoria. El programa funciona, pero con cada llamada consume más y más recursos. En proyectos modernos esto es inaceptable.

Cómo solucionarlo:

\n
• Usa punteros inteligentes (std::unique_ptr, std::shared_ptr) — liberan la memoria automáticamente.
\n
• Si no puedes evitar new/delete, coloca siempre el delete inmediatamente después del último uso.
\n

#include <memory>\nstd::unique_ptr<int> ptr = std::make_unique<int>(42);\n// La memoria se liberará automáticamente al salir del ámbito

2. Usar using namespace std; en el ámbito global

Esta línea es como una bomba de tiempo. En pequeños ejemplos de aprendizaje funciona, pero en un proyecto real provoca conflictos de nombres.

Problema:

#include <iostream>\n#include <vector>\nusing namespace std;\n\n// Un año después, aparece tu propia clase vector\nclass vector { ... }; // ¡Error de compilación!

Los nombres de std (por ejemplo, vector, cout) se vuelven globales, y cualquier clase tuya con el mismo nombre causará una colisión.

Mejor así:

\n
• Escribe std::cout, std::vector explícitamente.
\n
• O usa using std::cout; solo para nombres específicos.
\n

3. Comportamiento indefinido: dispararse en el pie

El error más traicionero al aprender C++ es el comportamiento indefinido (UB — Undefined Behavior). El compilador no dará error, el programa puede funcionar, o puede borrar tu disco duro. Es broma, pero no está lejos de la realidad.

Ejemplos de UB:

\n
• Salirse de los límites de un array: int arr[5]; arr[10] = 42;
\n
• Desreferenciar un puntero nulo: int* p = nullptr; *p = 5;
\n
• Usar una variable antes de inicializarla.
\n

int x; // no inicializada\nstd::cout << x; // UB: puede mostrar basura, 0 o causar un crash

Consejo: inicializa siempre las variables. Usa std::array o std::vector en lugar de arrays crudos: verifican los límites (en modo debug).

4. Confundir un puntero con una referencia

Los principiantes a menudo no entienden la diferencia entre int* p e int& ref. Error: intentan reasignar una referencia, o se olvidan de desreferenciar un puntero.

Error típico:

void change(int* p) {\n    p = new int(10); // cambiamos la copia local del puntero, el original no cambia\n}\n\nint main() {\n    int* ptr = nullptr;\n    change(ptr);\n    std::cout << *ptr; // UB: ptr sigue siendo nullptr\n}

Cómo hacerlo bien: pasa el puntero por referencia (int*& p) o usa referencias si no necesitas cambiar la dirección.