Declaración de arrays con tamaño fijo

Los arrays son estructuras de datos fundamentales que nos permiten almacenar múltiples valores del mismo tipo bajo un único nombre de variable. En lugar de crear variables individuales para cada elemento, podemos usar un array para organizar y manipular colecciones de datos de forma eficiente.

En C, los arrays tienen un tamaño fijo que debe definirse en el momento de la declaración. Esto significa que una vez creado un array, su tamaño no puede cambiar durante la ejecución del programa. Vamos a ver cómo declarar arrays con tamaño fijo en C.

Sintaxis básica

La sintaxis para declarar un array en C es:

tipo nombreArray[tamaño];

Donde:

• tipo: es el tipo de datos que almacenará el array (int, float, char, etc.)
• nombreArray: es el identificador o nombre del array
• tamaño: es el número de elementos que podrá contener el array

Por ejemplo, para declarar un array de 5 enteros:

int calificaciones[5];

Este código crea un array llamado calificaciones que puede almacenar 5 valores enteros.

Inicialización de arrays

Existen varias formas de inicializar un array en C:

1. Inicialización en la declaración con lista de valores

Podemos asignar valores iniciales a un array en el momento de su declaración:

int calificaciones[5] = {85, 90, 78, 92, 88};

Este código crea un array de 5 enteros y asigna los valores especificados a cada posición.

2. Inicialización parcial

No es necesario inicializar todos los elementos. Si proporcionamos menos valores que el tamaño del array, los elementos restantes se inicializan automáticamente a cero:

int calificaciones[5] = {85, 90, 78};  // Los últimos dos elementos serán 0

En este ejemplo, calificaciones[3] y calificaciones[4] tendrán el valor 0.

3. Inicialización sin especificar el tamaño

Si inicializamos el array con una lista de valores, podemos omitir el tamaño y el compilador lo determinará automáticamente:

int calificaciones[] = {85, 90, 78, 92, 88};  // Tamaño 5 determinado automáticamente

El compilador cuenta el número de elementos en la lista de inicialización y crea un array de ese tamaño.

4. Inicialización con ceros

Para inicializar todos los elementos de un array a cero, podemos usar:

int calificaciones[5] = {0};  // Todos los elementos se inicializan a 0

Ejemplos prácticos

Veamos algunos ejemplos prácticos de declaración e inicialización de arrays:

Ejemplo 1: Array de temperaturas diarias

// Declaración de un array para almacenar temperaturas de la semana
float temperaturas[7];

// Inicialización posterior
temperaturas[0] = 22.5;  // Lunes
temperaturas[1] = 23.8;  // Martes
temperaturas[2] = 21.0;  // Miércoles
temperaturas[3] = 20.2;  // Jueves
temperaturas[4] = 24.5;  // Viernes
temperaturas[5] = 26.1;  // Sábado
temperaturas[6] = 25.3;  // Domingo

Ejemplo 2: Array de notas de estudiantes

// Declaración e inicialización en una sola línea
int notas[5] = {75, 82, 93, 68, 90};

// Equivalente a:
int notas[5];
notas[0] = 75;
notas[1] = 82;
notas[2] = 93;
notas[3] = 68;
notas[4] = 90;

Consideraciones importantes

1. Tamaño fijo: Una vez declarado, el tamaño del array no puede cambiar durante la ejecución del programa.

2. Memoria contigua: Los elementos de un array se almacenan en posiciones de memoria contiguas, lo que permite un acceso eficiente.

3. Declaración con constantes: El tamaño del array debe ser una constante o una expresión constante conocida en tiempo de compilación:

const int NUM_ESTUDIANTES = 5;
float promedios[NUM_ESTUDIANTES];  // Válido

// También es válido:
#define MAX_ELEMENTOS 100
int datos[MAX_ELEMENTOS];

4. Tamaño en bytes: Podemos calcular el tamaño total en bytes de un array usando el operador sizeof:

int numeros[10];
int tamanoBytes = sizeof(numeros);  // Normalmente 40 bytes (10 ints * 4 bytes)

5. Variables automáticas vs. globales: Los arrays declarados dentro de funciones (variables automáticas) no se inicializan automáticamente, mientras que los arrays globales sí se inicializan a cero por defecto:

// Array global (inicializado a ceros automáticamente)
int arrayGlobal[100];

void funcion() {
    // Array local (contiene valores indeterminados si no se inicializa)
    int arrayLocal[100];
    
    // Es mejor inicializarlo explícitamente
    int arrayInicializado[100] = {0};
}

Los arrays son una herramienta fundamental en C para manejar colecciones de datos del mismo tipo. Aunque tienen un tamaño fijo, su simplicidad y eficiencia los hacen extremadamente útiles para muchas aplicaciones de programación.

Acceso a elementos con índices

Una vez que hemos declarado un array en C, necesitamos una forma de acceder a los elementos individuales almacenados en él. Para esto utilizamos los índices, que son valores numéricos que indican la posición de cada elemento dentro del array.

En C, los índices de los arrays siempre comienzan en 0, no en 1. Esto significa que el primer elemento de cualquier array se encuentra en la posición 0, el segundo elemento en la posición 1, y así sucesivamente. Esta característica es fundamental para entender cómo trabajar con arrays en C.

Sintaxis para acceder a elementos

Para acceder a un elemento específico de un array, utilizamos la siguiente sintaxis:

nombreArray[índice]

Donde:

• nombreArray: es el identificador del array
• índice: es la posición numérica del elemento al que queremos acceder (comenzando desde 0)

Ejemplos básicos de acceso

Veamos algunos ejemplos sencillos:

int notas[5] = {85, 90, 78, 92, 88};

// Acceder al primer elemento (índice 0)
int primeraNota = notas[0];  // primeraNota = 85

// Acceder al tercer elemento (índice 2)
int terceraNota = notas[2];  // terceraNota = 78

// Acceder al último elemento (índice 4)
int ultimaNota = notas[4];  // ultimaNota = 88

Modificación de elementos

No solo podemos leer valores de un array, también podemos modificarlos utilizando la misma notación de índices:

float temperaturas[7] = {22.5, 23.8, 21.0, 20.2, 24.5, 26.1, 25.3};

// Modificar la temperatura del jueves (índice 3)
temperaturas[3] = 19.8;

// Incrementar la temperatura del sábado (índice 5)
temperaturas[5] = temperaturas[5] + 1.5;  // Ahora es 27.6

Uso de variables como índices

Una característica poderosa de los arrays es que podemos utilizar variables como índices, lo que nos permite acceder a elementos de forma dinámica:

int posicion = 2;
int notas[5] = {85, 90, 78, 92, 88};

// Acceder al elemento en la posición indicada por la variable
int notaSeleccionada = notas[posicion];  // notaSeleccionada = 78

// Modificar el elemento en la posición indicada
notas[posicion] = 80;  // Ahora notas = {85, 90, 80, 92, 88}

Expresiones como índices

También podemos usar expresiones aritméticas como índices:

int i = 1;
int valores[5] = {10, 20, 30, 40, 50};

// Usar una expresión como índice
int valor = valores[i + 2];  // Equivale a valores[3], que es 40

// Otra expresión
int resultado = valores[i] + valores[i + 1];  // 20 + 30 = 50

Ejemplo práctico: Trabajando con notas de estudiantes

Veamos un ejemplo más completo donde accedemos y manipulamos elementos de un array:

#include <stdio.h>

int main() {
    // Array de notas de 5 estudiantes
    int notas[5] = {75, 82, 93, 68, 90};
    
    // Mostrar la nota del primer estudiante
    printf("Nota del estudiante 1: %d\n", notas[0]);
    
    // Cambiar la nota del estudiante que reprobó (índice 3)
    printf("Nota original del estudiante 4: %d\n", notas[3]);
    notas[3] = 70;  // Actualizar la nota después de revisión
    printf("Nota actualizada del estudiante 4: %d\n", notas[3]);
    
    // Calcular el promedio de las notas del primer y último estudiante
    float promedio = (notas[0] + notas[4]) / 2.0f;
    printf("Promedio entre el primer y último estudiante: %.1f\n", promedio);
    
    return 0;
}

Este programa muestra cómo podemos acceder a elementos específicos, modificarlos y utilizarlos en cálculos.

Ejemplo práctico: Registro de temperaturas

Otro ejemplo útil es el manejo de temperaturas semanales:

#include <stdio.h>

int main() {
    float temperaturas[7] = {22.5, 23.8, 21.0, 20.2, 24.5, 26.1, 25.3};
    char *dias[] = {"Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado", "Domingo"};
    
    // Mostrar la temperatura más alta y su día
    int indiceMaximo = 0;
    
    for (int i = 1; i < 7; i++) {
        if (temperaturas[i] > temperaturas[indiceMaximo]) {
            indiceMaximo = i;
        }
    }
    
    printf("La temperatura más alta fue %.1f°C el día %s\n", 
           temperaturas[indiceMaximo], dias[indiceMaximo]);
    
    return 0;
}

Consideraciones importantes

1. Límites del array: C no verifica automáticamente si un índice está dentro de los límites válidos del array. Acceder a posiciones fuera de los límites puede causar comportamientos impredecibles o errores graves:

int numeros[5] = {10, 20, 30, 40, 50};
int valor = numeros[7];  // ¡ERROR! Acceso fuera de los límites del array

2. Índices negativos: Los índices negativos no son válidos en C estándar y pueden causar errores:

int numeros[5] = {10, 20, 30, 40, 50};
int valor = numeros[-1];  // ¡ERROR! Índice negativo

3. Cálculo de posiciones: Es común calcular posiciones específicas dentro de un array:

int matriz[10];
int medio = matriz[10/2];       // Accede al elemento en la mitad
int ultimo = matriz[10-1];      // Accede al último elemento
int penultimo = matriz[10-2];   // Accede al penúltimo elemento

4. Operaciones con elementos: Podemos realizar operaciones directamente con los elementos del array:

int valores[3] = {5, 10, 15};
valores[0] = valores[1] + valores[2];  // valores[0] ahora es 25
valores[1]++;                          // Incrementa valores[1] a 11
valores[2] *= 2;                       // Multiplica valores[2] por 2 (ahora es 30)

El acceso a elementos mediante índices es una operación fundamental al trabajar con arrays en C. Dominar esta técnica te permitirá manipular eficientemente colecciones de datos y resolver problemas más complejos a medida que avances en tu aprendizaje de programación.

Recorrer arrays con for

Una de las operaciones más comunes al trabajar con arrays es recorrerlos para procesar todos sus elementos. En C, el bucle for es la herramienta ideal para esta tarea, ya que nos permite iterar de forma sistemática a través de cada posición del array.

Estructura básica para recorrer arrays

La estructura típica para recorrer un array completo con un bucle for es:

for (int i = 0; i < tamaño; i++) {
    // Operaciones con array[i]
}

Donde:

• i es la variable de control que funciona como índice
• tamaño es el número de elementos del array
• array[i] accede al elemento en la posición actual

Esta estructura garantiza que visitemos cada elemento del array exactamente una vez, desde el primero (índice 0) hasta el último (índice tamaño-1).

Ejemplo: Mostrar elementos de un array

Veamos un ejemplo sencillo donde mostramos todos los elementos de un array de notas:

#include <stdio.h>

int main() {
    int notas[5] = {85, 90, 78, 92, 88};
    
    printf("Notas de los estudiantes:\n");
    
    for (int i = 0; i < 5; i++) {
        printf("Estudiante %d: %d\n", i + 1, notas[i]);
    }
    
    return 0;
}

Este programa muestra las notas de 5 estudiantes, numerándolos del 1 al 5 (aunque los índices van del 0 al 4).

Cálculos con elementos del array

Podemos usar bucles for para realizar cálculos con los elementos del array, como sumar todos los valores o encontrar el máximo:

#include <stdio.h>

int main() {
    float temperaturas[7] = {22.5, 23.8, 21.0, 20.2, 24.5, 26.1, 25.3};
    float suma = 0;
    
    // Calcular la suma de todas las temperaturas
    for (int i = 0; i < 7; i++) {
        suma += temperaturas[i];
    }
    
    // Calcular y mostrar el promedio
    float promedio = suma / 7;
    printf("Temperatura promedio de la semana: %.2f°C\n", promedio);
    
    return 0;
}

Encontrar valores específicos

También podemos usar bucles para buscar valores específicos dentro de un array:

#include <stdio.h>

int main() {
    int notas[5] = {85, 90, 78, 92, 88};
    int notaMaxima = notas[0]; // Asumimos que el primer elemento es el máximo
    int posicionMaxima = 0;
    
    // Buscar la nota más alta
    for (int i = 1; i < 5; i++) {
        if (notas[i] > notaMaxima) {
            notaMaxima = notas[i];
            posicionMaxima = i;
        }
    }
    
    printf("La nota más alta es %d, obtenida por el estudiante %d\n", 
           notaMaxima, posicionMaxima + 1);
    
    return 0;
}

Modificar elementos durante el recorrido

Podemos modificar los elementos de un array mientras lo recorremos:

#include <stdio.h>

int main() {
    int valores[5] = {10, 20, 30, 40, 50};
    
    // Multiplicar cada elemento por 2
    for (int i = 0; i < 5; i++) {
        valores[i] = valores[i] * 2;
    }
    
    // Mostrar el array modificado
    printf("Valores duplicados:\n");
    for (int i = 0; i < 5; i++) {
        printf("%d ", valores[i]);
    }
    printf("\n");
    
    return 0;
}

Recorrido en orden inverso

También podemos recorrer un array desde el último elemento hasta el primero:

#include <stdio.h>

int main() {
    int numeros[5] = {10, 20, 30, 40, 50};
    
    printf("Elementos en orden inverso:\n");
    for (int i = 4; i >= 0; i--) {
        printf("%d ", numeros[i]);
    }
    printf("\n");
    
    return 0;
}

Uso de sizeof para determinar el tamaño

Una práctica recomendada es usar el operador sizeof para calcular automáticamente el tamaño del array, lo que hace el código más mantenible:

#include <stdio.h>

int main() {
    int valores[] = {5, 10, 15, 20, 25, 30};
    int tamano = sizeof(valores) / sizeof(valores[0]);
    
    printf("El array tiene %d elementos\n", tamano);
    
    // Recorrer usando el tamaño calculado
    for (int i = 0; i < tamano; i++) {
        printf("valores[%d] = %d\n", i, valores[i]);
    }
    
    return 0;
}

La expresión sizeof(valores) / sizeof(valores[0]) calcula el número de elementos dividiendo el tamaño total del array entre el tamaño de un solo elemento.

Ejemplo práctico: Análisis de temperaturas

Veamos un ejemplo más completo donde analizamos las temperaturas de una semana:

#include <stdio.h>

int main() {
    float temperaturas[7] = {22.5, 23.8, 21.0, 20.2, 24.5, 26.1, 25.3};
    char *dias[] = {"Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado", "Domingo"};
    
    float suma = 0, maxima = temperaturas[0], minima = temperaturas[0];
    int diaMax = 0, diaMin = 0;
    
    // Analizar temperaturas
    for (int i = 0; i < 7; i++) {
        // Acumular para el promedio
        suma += temperaturas[i];
        
        // Buscar temperatura máxima
        if (temperaturas[i] > maxima) {
            maxima = temperaturas[i];
            diaMax = i;
        }
        
        // Buscar temperatura mínima
        if (temperaturas[i] < minima) {
            minima = temperaturas[i];
            diaMin = i;
        }
    }
    
    // Calcular promedio
    float promedio = suma / 7;
    
    // Mostrar resultados
    printf("Análisis de temperaturas de la semana:\n");
    printf("Temperatura promedio: %.2f°C\n", promedio);
    printf("Temperatura máxima: %.2f°C (%s)\n", maxima, dias[diaMax]);
    printf("Temperatura mínima: %.2f°C (%s)\n", minima, dias[diaMin]);
    
    return 0;
}

Recorrido parcial de arrays

No siempre necesitamos recorrer todo el array. Podemos ajustar los límites del bucle para procesar solo una parte:

#include <stdio.h>

int main() {
    int valores[10] = {5, 10, 15, 20, 25, 30, 35, 40, 45, 50};
    
    // Recorrer solo la primera mitad
    printf("Primera mitad: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", valores[i]);
    }
    printf("\n");
    
    // Recorrer solo la segunda mitad
    printf("Segunda mitad: ");
    for (int i = 5; i < 10; i++) {
        printf("%d ", valores[i]);
    }
    printf("\n");
    
    return 0;
}

Recorrido con saltos

También podemos recorrer un array saltando elementos, por ejemplo, procesando solo los elementos en posiciones pares o impares:

#include <stdio.h>

int main() {
    int numeros[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    // Mostrar elementos en posiciones pares (0, 2, 4, 6, 8)
    printf("Elementos en posiciones pares: ");
    for (int i = 0; i < 10; i += 2) {
        printf("%d ", numeros[i]);
    }
    printf("\n");
    
    // Mostrar elementos en posiciones impares (1, 3, 5, 7, 9)
    printf("Elementos en posiciones impares: ");
    for (int i = 1; i < 10; i += 2) {
        printf("%d ", numeros[i]);
    }
    printf("\n");
    
    return 0;
}

El recorrido de arrays con bucles for es una técnica fundamental en la programación en C. Dominar esta habilidad te permitirá procesar eficientemente colecciones de datos y resolver una amplia variedad de problemas de programación.