Arrays y cadenas de estilo C

De dónde venimos

Hasta ahora cada dato tenía su propia variable: nota1, nota2. Si quisieras el promedio de 300 notas con lo visto en Variables y tipos, tendrías que declarar 300 variables. Evidentemente no es así como se hace.

Esta página introduce la primera estructura para guardar muchos valores del mismo tipo bajo un solo nombre, y combina directamente dos cosas que ya sabes: el bucle for para recorrerlos y las funciones para pasarlos a otro lado. Ese último punto trae una sorpresa que es, literalmente, la puerta de entrada a los punteros.

Qué es un array

Un array (arreglo) es un bloque de memoria contiguo que contiene un número fijo de elementos del mismo tipo. “Contiguo” significa que los elementos están pegados uno detrás de otro en memoria, sin huecos: el elemento 5 está inmediatamente después del 4.

#include <iostream>

int main() {
    int notas[5] = {7, 4, 6, 3, 5};   // 5 enteros, inicializados

    std::cout << "Primera nota: " << notas[0] << "\n";   // índice 0
    std::cout << "Última nota:  " << notas[4] << "\n";   // índice 4

    notas[2] = 10;                                        // modificar un elemento
    std::cout << "Tercera nota modificada: " << notas[2] << "\n";
    return 0;
}

g++ -std=c++17 -Wall -o arrays arrays.cpp
./arrays

Primera nota: 7
Última nota:  5
Tercera nota modificada: 10

Dos reglas que no se negocian:

1. Los índices empiezan en 0. Un array de 5 elementos tiene índices válidos 0, 1, 2, 3, 4. No existe notas[5].
2. El tamaño es fijo y se decide al compilar. No puedes agrandar un array después. int notas[n]; con n leído por consola no es C++ estándar (aunque GCC lo acepte como extensión).

Recorrer un array

Con el for clásico, usando el índice:

#include <iostream>

int main() {
    const int TOTAL = 5;
    int notas[TOTAL] = {7, 4, 6, 3, 5};

    int suma = 0;
    for (int i = 0; i < TOTAL; ++i) {    // ojo: i < TOTAL, no i <= TOTAL
        suma += notas[i];
    }

    std::cout << "Suma: " << suma << "\n";
    std::cout << "Promedio: " << static_cast<double>(suma) / TOTAL << "\n";
    return 0;
}

Suma: 25
Promedio: 5

Dos detalles heredados de páginas anteriores: la condición es i < TOTAL (con <= te pasarías un elemento, el error clásico llamado off-by-one), y el static_cast<double> está ahí para evitar la división entera que convertiría 25 / 5 en un entero.

El for basado en rango

Desde C++11 puedes recorrer el array sin índices, que es la forma preferida cuando no necesitas saber en qué posición estás:

#include <iostream>

int main() {
    int notas[5] = {7, 4, 6, 3, 5};

    for (int nota : notas) {          // "para cada nota dentro de notas"
        std::cout << nota << " ";
    }
    std::cout << "\n";
    return 0;
}

7 4 6 3 5 

Al no haber índice, es imposible salirse del rango. Por eso se prefiere siempre que sea posible.

Arrays y funciones: la primera sorpresa

Aquí es donde el modelo mental de la página anterior se rompe. En Funciones quedó establecido que los argumentos se pasan por valor, es decir, se copian. Con los arrays, no:

#include <iostream>

void ponerEnCero(int datos[], int cantidad) {
    for (int i = 0; i < cantidad; ++i) {
        datos[i] = 0;             // modifica el array ORIGINAL
    }
}

int main() {
    int notas[5] = {7, 4, 6, 3, 5};
    ponerEnCero(notas, 5);

    std::cout << notas[0] << " " << notas[4] << "\n";   // imprime 0 0
    return 0;
}

0 0

No hicimos nada especial —no hay ningún &— y aun así la función modificó el original. La razón es que un array, al pasarlo a una función, se degrada (decay) a un puntero a su primer elemento. La función no recibe 5 enteros: recibe una dirección de memoria. Y con esa dirección puede tocar los datos reales.

Dentro de main(), en cambio, el array sí conoce su tamaño, y puedes obtenerlo con sizeof:

int notas[5] = {7, 4, 6, 3, 5};
int cantidad = sizeof(notas) / sizeof(notas[0]);   // 20 bytes / 4 bytes = 5

Cadenas de estilo C

Una cadena de estilo C (C-string) es simplemente un array de char que termina con un carácter especial: el carácter nulo '\0'. Ese terminador es la única marca de dónde acaba el texto.

#include <iostream>
#include <cstring>   // funciones de C-strings: strlen, strcpy...
#include <string>    // std::string

int main() {
    const char saludo[] = "Hola";     // ocupa 5 chars: 'H','o','l','a','\0'
    std::string moderno = "Hola";     // la versión de la Standard Library

    std::cout << "C-string: " << saludo  << " (largo " << std::strlen(saludo) << ")\n";
    std::cout << "std::string: " << moderno << " (largo " << moderno.size() << ")\n";
    return 0;
}

g++ -std=c++17 -Wall -o cadenas cadenas.cpp
./cadenas

C-string: Hola (largo 4)
std::string: Hola (largo 4)

Aunque "Hola" tiene 4 letras, el array saludo ocupa 5 bytes: el '\0' invisible del final cuenta. strlen devuelve 4 porque cuenta caracteres hasta el terminador, sin incluirlo.

Siguiente paso

Este capítulo dejó dos cabos sueltos deliberados: qué es exactamente eso a lo que “se degrada” un array, y por qué una función puede modificar datos ajenos sin usar &. La respuesta a ambos es la misma, y es el tema de la próxima página: Punteros.