¿Por qué un puntero y no un objeto? C++ bajo el capó para principiantes

Introducción: la pregunta eterna del principiante

Si alguna vez ha mirado en Stack Overflow la sección de C++, seguramente habrá visto la pregunta con miles de visitas: «¿Por qué debería usar un puntero y no el objeto en sí?». Y no es una curiosidad ociosa. Todo aquel que empieza a aprender C++ después de Python o JavaScript se enfrenta a este dilema. En teoría, el objeto es cómodo: lo creas, llamas al método, te olvidas. ¿Para qué entonces esos asteriscos, flechas y new?

En realidad, la respuesta está en cómo C++ gestiona la memoria bajo el capó. En este artículo no solo daremos una definición seca, sino que analizaremos escenarios reales de la vida del programador donde el puntero se convierte no solo en algo conveniente, sino en la única opción correcta. ¿Listo para mirar dentro del motor de tu código? ¡Allá vamos!

Objeto vs Puntero: ¿qué dice el compilador?

Vayamos al grano. Imagine que está escribiendo una clase Monster para su juego RPG.

class Monster {\npublic:\n    Monster() { std::cout << "¡Monstruo creado!\\n"; }\n    ~Monster() { std::cout << "¡Monstruo destruido!\\n"; }\n    void roar() { std::cout << "RAAAWR!\\n"; }\n};

Ahora, dos formas de usar esta clase:

1. Objeto en la pila (gestión automática)

void spawnOnStack() {\n    Monster m;  // El objeto vive aquí\n    m.roar();\n}  // Aquí m se destruye automáticamente

2. Puntero al montón (gestión manual)

void spawnOnHeap() {\n    Monster* m = new Monster(); // Objeto en el montón\n    m->roar();\n    delete m;  // ¡Obligatorio eliminarlo nosotros mismos!\n}

Parecería que la primera opción es más simple y segura. ¿Para qué la segunda? Bajo el capó aquí se esconde la diferencia clave: la pila (stack) y el montón (heap).

\n
• Pila — pequeña, rápida, pero el objeto solo vive dentro del bloque {}.
\n
• Montón — grande, más lento, pero el objeto vive hasta que usted lo elimine.
\n

Cuando el tamaño del objeto es enorme (por ejemplo, una textura 4K), almacenarlo en la pila significa arriesgarse a un desbordamiento de pila. Aquí es donde entran en escena los punteros.

Top 5 razones para usar un puntero (en lugar de un objeto)

Ahora que entendemos la diferencia básica, analicemos situaciones concretas donde el puntero no es un capricho, sino una necesidad.

1. Polimorfismo: cuando el tipo no se conoce de antemano

Esta es, quizás, la razón más común. Supongamos que tiene una clase base Character y las derivadas Warrior, Mage. Si crea un objeto en la pila, está obligado a indicar el tipo exacto:

Warrior w;  // Todo bien, pero no es polimórfico

¿Y si el tipo de personaje se elige durante el juego? Solo el puntero da flexibilidad:

Character* hero;\nif (choice == "warrior")\n    hero = new Warrior();\nelse\n    hero = new Mage();\n\nhero->attack(); // ¡Se llamará al método de la clase derivada!\ndelete hero;

Bajo el capó: el compilador usa la tabla de funciones virtuales (vtable). El puntero almacena la dirección donde se encuentra el objeto y, al llamar al método, consulta la vtable. Con un objeto en la pila, este truco no funciona: el tipo está fijado rígidamente.

2. Paso a una función sin copia

Observe este código:

void process(Monster m) { // ¡Paso por valor!\n    m.roar();\n}\n\nMonster bigBoss;\nprocess(bigBoss); // ¡Copia!

Aquí process recibe una copia del objeto. Si Monster contiene un array de 100 MB, acaba de copiar 100 MB sin motivo. El puntero resuelve el problema:

void process(Monster* m)