Punteros y referencias

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy — lección 13 de 104.

Ahora que entiendes la memoria stack y heap, exploremos las herramientas que te permiten trabajar directamente con ubicaciones de memoria: punteros y referencias.

Un puntero almacena la dirección de memoria de otra variable. Se declara con * y se obtiene una dirección usando &.

int value = 42;
int* ptr = &value;    // ptr contiene la dirección de value

std::cout << ptr;     // Imprime la dirección de memoria
std::cout << *ptr;    // Desreferencia: imprime 42

Una referencia es un alias para una variable existente. Una vez vinculada, siempre se refiere a esa variable. Se declara con &.

int value = 42;
int& ref = value;     // ref es un alias para value

ref = 100;            // Cambia value a 100
std::cout << value;   // Imprime 100

Diferencias clave:

Punteros	Referencias
Pueden ser nulos	Deben ser inicializados
Pueden ser reasignados	No pueden ser re-vinculados
Usa `*` para acceder al valor	Accede al valor directamente
Pueden no apuntar a nada	Siempre son válidas

Ambos son esenciales para pasar objetos a funciones de manera eficiente sin realizar copias, y para trabajar con memoria asignada en el heap. Las referencias son más seguras y sencillas, mientras que los punteros ofrecen más flexibilidad cuando necesitas reasignar o verificar si son null.

Desafío

Fácil

Vamos a construir un sistema simple de manipulación de valores que demuestre cómo los punteros y las referencias funcionan de manera diferente al modificar datos.

Crearás dos archivos para organizar tu código:

ValueOps.h: Define tres funciones que modifican valores enteros de diferentes maneras:
- doubleByPointer(int* ptr) — toma un puntero y duplica el valor al que apunta
- tripleByReference(int& ref) — toma una referencia y triplica el valor
- swapValues(int* a, int* b) — toma dos punteros e intercambia los valores a los que apuntan
main.cpp: Lee dos enteros de la entrada, luego demuestra tanto los punteros como las referencias:
- Imprime los valores originales: "Original: <first> <second>"
- Usa doubleByPointer en el primer valor, luego imprime: "After double: <first>"
- Usa tripleByReference en el segundo valor, luego imprime: "After triple: <second>"
- Usa swapValues para intercambiar ambos valores, luego imprime: "After swap: <first> <second>"

Al llamar a funciones con punteros, recuerda usar el operador de dirección (&) para pasar la dirección de la variable. Las referencias funcionan de manera más natural: simplemente pasa la variable directamente.

Incluye tu archivo de cabecera en main.cpp usando #include "ValueOps.h".

Hoja de referencia

Un puntero almacena la dirección de memoria de otra variable. Se declara con * y se obtiene una dirección usando &:

int value = 42;
int* ptr = &value;    // ptr contiene la dirección de value

std::cout << ptr;     // Imprime la dirección de memoria
std::cout << *ptr;    // Desreferencia: imprime 42

Una referencia es un alias para una variable existente. Se declara con &:

int value = 42;
int& ref = value;     // ref es un alias para value

ref = 100;            // Cambia value a 100
std::cout << value;   // Imprime 100

Diferencias clave:

Punteros	Referencias
Pueden ser nulos	Deben ser inicializadas
Pueden ser reasignados	No pueden ser reasignadas
Usan `*` para acceder al valor	Acceden al valor directamente
Pueden no apuntar a nada	Siempre son válidas

Al llamar a funciones con punteros, use el operador de dirección (&) para pasar la dirección de la variable. Las referencias funcionan directamente: simplemente pase la variable.

Pruébalo tú mismo

#include <iostream>
#include "ValueOps.h"
using namespace std;

int main() {
    // Lee dos enteros de la entrada
    int first, second;
    cin >> first;
    cin >> second;
    
    // Imprime los valores originales
    cout << "Original: " << first << " " << second << endl;
    
    // TODO: Usa doubleByPointer en el primer valor (pasa la dirección usando &)
    
    // TODO: Imprime después de duplicar
    
    // TODO: Usa tripleByReference en el segundo valor (pasa la variable directamente)
    
    // TODO: Imprime después de triplicar
    
    // TODO: Usa swapValues para intercambiar ambos valores (pasa las direcciones usando &)
    
    // TODO: Imprime después del intercambio
    
    return 0;
}