Un array de tamaño fijo, como int arr[5], es una secuencia contigua de elementos almacenados directamente en la pila (stack). Cuando declaras este objeto, el compilador reserva un bloque de memoria exacto para esos cinco enteros. Sin embargo, hay un comportamiento fundamental que suele causar errores: el decay (o degradación).
En la mayoría de las expresiones, el nombre de un array no se comporta como el objeto completo, sino que se convierte implícitamente en un puntero que apunta al primer elemento. Esto ocurre porque, para optimizar el rendimiento, el lenguaje decide que pasar un array entero a una función no debe implicar copiar todos sus elementos, sino simplemente pasar la dirección de memoria de su primer elemento. El problema es que, al realizar esta conversión, el array “pierde” su información de tamaño. Si intentas usar sizeof(arr) dentro de una función que recibe el array como parámetro, no obtendrás el tamaño del array, sino el tamaño del puntero.
Debes usar arrays de estilo C solo cuando trabajes con APIs de bajo nivel o hardware específico. Para el desarrollo moderno, la alternativa estándar es std::array [C++11], que es un contenedor de envoltorio (wrapper) que mantiene el tamaño como parte de su tipo. El error más crítico que puedes cometer es acceder a un índice fuera de los límites (por ejemplo, arr[10] en un array de 5 elementos). Como C++ prioriza el rendimiento y no realiza comprobaciones de límites por defecto, esto provoca un comportamiento indefinido (Undefined Behavior), lo que puede resultar en un fallo de segmentación o, peor aún, en la corrupción silenciosa de la memoria.
#include <iostream>
#include <array>
#include <stdexcept>
// Debido al "decay", 'ptr' no es un array, es un puntero (int*).
void analizar_decay(int ptr[]) {
// ERROR COMÚN: sizeof(ptr) devuelve el tamaño del puntero (4 u 8 bytes),
// no el tamaño del array original.
std::cout << "[Función] sizeof(ptr) es: " << sizeof(ptr) << " bytes\n";
}
int main() {
// 1. Array de estilo C (Fixed-size array) en el stack
int arr_c[5] = {10, 20, 30, 40, 50};
// 2. std::array [C++11]: La alternativa moderna y segura.
// El tamaño es parte del tipo: std::array<int, 5>.
std::array<int, 5> arr_cpp = {1, 2, 3, 4, 5};
// 3. Array multidimensional
// En memoria, se almacena de forma contigua fila por fila (row-major layout).
int matriz[2][3] = { {1, 2, 3}, {4, 5, 6} };
// Mostrar diferencias de sizeof
std::cout << "[Main] sizeof(arr_c): " << sizeof(arr_c) << " bytes\n";
std::cout << "[Main] sizeof(arr_cpp): " << sizeof(arr_cpp) << " bytes\n";
analizar_decay(arr_c);
// Uso de .at() para seguridad en tiempo de ejecución
std::cout << "Acceso seguro con std::array:\n";
try {
// .at() lanza std::out_of_range si el índice es inválido
std::cout << "Elemento índice 2: " << arr_cpp.at(2) << "\n";
std::cout << "Elemento índice 10: " << arr_cpp.at(10) << "\n";
} catch (const std::out_of_range& e) {
std::cout << "Error capturado: " << e.what() << "\n";
}
std::cout << "Valor en matriz[1][0]: " << matriz[1][0] << "\n";
return 0;
}
En el código anterior, observamos cómo arr_c ocupa 20 bytes (asumiendo int de 4 bytes) en el scope de main, pero al pasarlo a analizar_decay, la variable ptr se convierte en un simple puntero. Por eso, sizeof(ptr) devuelve únicamente el tamaño de la dirección de memoria (típicamente 8 bytes en sistemas de 64 bits).
En cambio, arr_cpp es un objeto de la biblioteca estándar que encapsula el array. A diferencia del array de C, std::array sabe su propio tamaño, lo que permite usar métodos como .at() para realizar comprobaciones de límites. Si intentas acceder a un índice inexistente, se lanza una excepción en lugar de corromper la memoria.
Finalmente, la matriz ilustra el layout de memoria: aunque visualmente la vemos como una cuadrícula, en la memoria es una línea continua. El elemento matriz[1][0] se encuentra inmediatamente después del último elemento de la primera fila, lo que hace que los arrays multidimensionales sean muy eficientes para el acceso secuencial debido a la localidad de caché.
El error frecuente
Un error clásico es intentar usar sizeof para determinar el tamaño de un array dentro de una función que recibe el array como argumento:
void error_logic(int arr[]) {
int n = sizeof(arr) / sizeof(arr[0]); // ERROR: n será 2 (8/4) en 64-bit, no el tamaño real.
for(int i = 0; i < n; ++i) { /* ... */ }
}
Este error es especialmente peligroso porque compila sin advertencias en muchos entornos, pero el bucle solo iterará sobre una fracción de los datos o accederá a memoria incorrecta. Si utilizas gcc o clang++ con la bandera -Wextra, es posible que recibas una advertencia sobre la pérdida de información, pero lo más seguro es confiar siempre en std::array o pasar el tamaño explícitamente como un segundo parámetro.
N° 28