Manipular elementos de arrays en C

Introducción

En este laboratorio, aprenderás cómo manipular elementos de arrays en programación C. El laboratorio cubre las habilidades fundamentales de declarar e inicializar arrays, acceder y modificar elementos de arrays, iterar a través de arrays, realizar cálculos con arrays y asignar dinámicamente memoria para arrays. Explorarás diversas técnicas para trabajar con arrays, incluyendo declarar e inicializar arrays con valores específicos, inicializar parcialmente arrays y asignar dinámicamente valores a elementos de arrays. Al final del laboratorio, tendrás una sólida comprensión de cómo administrar y manipular eficazmente estructuras de datos de arrays en C.

Skills Graph

Declarar e Inicializar un Array

En este paso, aprenderás cómo declarar e inicializar arrays en programación C. Los arrays son estructuras de datos fundamentales que te permiten almacenar múltiples elementos del mismo tipo en una ubicación de memoria contigua.

Comencemos creando un nuevo archivo C para explorar la declaración e inicialización de arrays:

cd ~/project
touch array_basics.c

Ahora, escribamos un programa que demuestre diferentes formas de declarar e inicializar arrays:

#include <stdio.h>

int main() {
    // Método 1: Declarar e inicializar un array con valores específicos
    int numbers[5] = {10, 20, 30, 40, 50};

    // Método 2: Declarar un array e inicializarlo más tarde
    int scores[3];
    scores[0] = 85;
    scores[1] = 92;
    scores[2] = 78;

    // Método 3: Inicializar parcialmente un array (los elementos restantes se establecen en 0)
    int grades[4] = {100, 95};

    // Imprimir los arrays para verificar la inicialización
    printf("Numbers array: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    printf("Scores array: ");
    for (int i = 0; i < 3; i++) {
        printf("%d ", scores[i]);
    }
    printf("\n");

    printf("Grades array: ");
    for (int i = 0; i < 4; i++) {
        printf("%d ", grades[i]);
    }
    printf("\n");

    return 0;
}

Compila y ejecuta el programa:

gcc array_basics.c -o array_basics
./array_basics

Ejemplo de salida:

Numbers array: 10 20 30 40 50
Scores array: 85 92 78
Grades array: 100 95 0 0

Desglosemos los métodos de inicialización de arrays:

1. int numbers[5] = {10, 20, 30, 40, 50};

   • Declara un array de enteros con 5 elementos
   • Inicializa todos los elementos con valores específicos
   • El tamaño se determina por el número de elementos en la lista de inicialización

2. int scores[3]; seguido de la asignación de elementos individuales

   • Declara un array primero
   • Asigna valores a elementos individuales más tarde
   • Útil cuando quieres establecer valores de forma dinámica

3. int grades[4] = {100, 95};

   • Inicializa parcialmente un array
   • Los elementos no especificados se establecen automáticamente en 0
   • Ayuda a ahorrar tiempo cuando solo quieres establecer algunos valores iniciales

Puntos clave a recordar:

• Los índices de los arrays comienzan en 0
• Debes especificar el tipo de elementos que almacenará el array
• Los arrays tienen un tamaño fijo una vez declarados
• Asegúrate siempre de no acceder a elementos de array más allá de su tamaño declarado

Acceder y Modificar Elementos de un Array

En este paso, aprenderás cómo acceder y modificar elementos individuales de un array en programación C. A partir del paso anterior, exploraremos cómo interactuar con los elementos de un array utilizando índices y demostraremos diversas formas de manipular el contenido de un array.

Creemos un nuevo archivo C para practicar el acceso y la modificación de elementos de un array:

cd ~/project
touch array_access.c

Ahora, escribamos un programa que demuestre el acceso y la modificación de elementos de un array:

#include <stdio.h>

int main() {
    // Declarar e inicializar un array
    int temperatures[5] = {72, 68, 75, 80, 65};

    // Accediendo a elementos individuales del array
    printf("First temperature: %d\n", temperatures[0]);
    printf("Third temperature: %d\n", temperatures[2]);

    // Modificando elementos del array
    temperatures[1] = 70;  // Cambiar el segundo elemento
    temperatures[4] = 73;  // Cambiar el último elemento

    // Imprimir el array modificado
    printf("Modified temperatures: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", temperatures[i]);
    }
    printf("\n");

    // Demostrar cálculo de elementos de un array
    int average = (temperatures[0] + temperatures[1] + temperatures[2] +
                   temperatures[3] + temperatures[4]) / 5;
    printf("Average temperature: %d\n", average);

    return 0;
}

Compila y ejecuta el programa:

gcc array_access.c -o array_access
./array_access

Ejemplo de salida:

First temperature: 72
Third temperature: 75
Modified temperatures: 72 70 75 80 73
Average temperature: 74

Desglosemos los conceptos clave:

1. Indexación de Arrays

   • Los arrays se acceden utilizando una indexación basada en cero
   • temperatures[0] se refiere al primer elemento
   • temperatures[4] se refiere al último elemento en un array de 5 elementos

2. Modificación de Elementos de un Array

   • Los elementos individuales se pueden cambiar directamente utilizando su índice
   • temperatures[1] = 70; reemplaza el segundo elemento con 70
   • Puedes modificar elementos en cualquier índice válido

3. Cálculos de Elementos de un Array

   • Puedes realizar cálculos utilizando elementos individuales de un array
   • En el ejemplo, calculamos la temperatura promedio
   • Accede a los elementos directamente por su índice en operaciones matemáticas

Errores Comunes a Evitar:

• Nunca accedas a un índice de array fuera de sus límites
• Los índices de los arrays comienzan en 0, no en 1
• Ten cuidado de no exceder el tamaño declarado del array

Iterar a través de un Array

En este paso, aprenderás diferentes métodos para iterar a través de arrays en programación C. La iteración es crucial para procesar eficientemente los elementos de un array y realizar diversas operaciones en su contenido.

Creemos un nuevo archivo C para explorar técnicas de iteración de arrays:

cd ~/project
touch array_iteration.c

Ahora, escribamos un programa que demuestre múltiples formas de iterar a través de un array:

#include <stdio.h>

int main() {
    // Declarar e inicializar un array de calificaciones de estudiantes
    int scores[6] = {85, 92, 78, 90, 88, 95};
    int total = 0;

    // Método 1: Usando un bucle for estándar
    printf("Method 1 - Standard For Loop:\n");
    for (int i = 0; i < 6; i++) {
        printf("Score %d: %d\n", i + 1, scores[i]);
        total += scores[i];
    }

    // Calcular e imprimir el promedio
    float average = (float)total / 6;
    printf("\nTotal Score: %d\n", total);
    printf("Average Score: %.2f\n", average);

    // Método 2: Iteración inversa
    printf("\nMethod 2 - Reverse Iteration:\n");
    printf("Scores in reverse order:\n");
    for (int i = 5; i >= 0; i--) {
        printf("Score %d: %d\n", i + 1, scores[i]);
    }

    // Método 3: Iteración con bucle while
    printf("\nMethod 3 - While Loop Iteration:\n");
    int j = 0;
    while (j < 6) {
        if (scores[j] >= 90) {
            printf("High score detected: %d\n", scores[j]);
        }
        j++;
    }

    return 0;
}

Compila y ejecuta el programa:

gcc array_iteration.c -o array_iteration
./array_iteration

Ejemplo de salida:

Method 1 - Standard For Loop:
Score 1: 85
Score 2: 92
Score 3: 78
Score 4: 90
Score 5: 88
Score 6: 95

Total Score: 528
Average Score: 88.00

Method 2 - Reverse Iteration:
Scores in reverse order:
Score 6: 95
Score 5: 88
Score 4: 90
Score 3: 78
Score 2: 92
Score 1: 85

Method 3 - While Loop Iteration:
High score detected: 92
High score detected: 90
High score detected: 95

Técnicas Clave de Iteración:

1. Bucle For Estándar

   • Método más común para la iteración de arrays
   • Permite un control preciso del índice
   • Ideal para el procesamiento hacia adelante

2. Iteración Inversa

   • Iterar desde el último elemento hasta el primero
   • Útil para requisitos de procesamiento específicos
   • Utiliza un contador de bucle descendente

3. Iteración con Bucle While

   • Proporciona un control flexible de la iteración
   • Puede incluir procesamiento condicional
   • Útil para lógica de iteración compleja

Principios Importantes de Iteración:

• Siempre define límites de bucle claros
• Utiliza la longitud del array para evitar el acceso fuera de los límites
• Elige el método de iteración más adecuado para tu tarea específica

Realizar Cálculos con Arrays

En este paso, aprenderás cómo realizar diversos cálculos con arrays en programación C. Exploraremos técnicas para encontrar los valores máximo y mínimo, calcular sumas, promedios y aplicar transformaciones matemáticas a los elementos de un array.

Creemos un nuevo archivo C para practicar cálculos con arrays:

cd ~/project
touch array_calculations.c

Ahora, escribamos un programa que demuestre diferentes técnicas de cálculo con arrays:

#include <stdio.h>
#include <limits.h>

int main() {
    // Declarar e inicializar un array de datos de ventas
    int sales[7] = {1200, 1500, 980, 1750, 1100, 1300, 1600};

    // Calcular las ventas totales
    int total_sales = 0;
    for (int i = 0; i < 7; i++) {
        total_sales += sales[i];
    }
    printf("Total Weekly Sales: $%d\n", total_sales);

    // Calcular las ventas promedio diarias
    float average_sales = (float)total_sales / 7;
    printf("Average Daily Sales: $%.2f\n", average_sales);

    // Encontrar las ventas máximas
    int max_sales = sales[0];  // Comenzar con el primer elemento
    for (int i = 1; i < 7; i++) {
        if (sales[i] > max_sales) {
            max_sales = sales[i];
        }
    }
    printf("Highest Daily Sales: $%d\n", max_sales);

    // Encontrar las ventas mínimas
    int min_sales = sales[0];  // Comenzar con el primer elemento
    for (int i = 1; i < 7; i++) {
        if (sales[i] < min_sales) {
            min_sales = sales[i];
        }
    }
    printf("Lowest Daily Sales: $%d\n", min_sales);

    // Aplicar un aumento porcentual
    float increase_percentage = 1.1;  // Aumento del 10%
    printf("\nSales After 10%% Increase:\n");
    for (int i = 0; i < 7; i++) {
        float increased_sale = sales[i] * increase_percentage;
        printf("Day %d: $%.2f\n", i + 1, increased_sale);
    }

    return 0;
}

Compila y ejecuta el programa:

gcc array_calculations.c -o array_calculations
./array_calculations

Ejemplo de salida:

Total Weekly Sales: $9430
Average Daily Sales: $1347.14
Highest Daily Sales: $1750
Lowest Daily Sales: $980

Sales After 10% Increase:
Day 1: $1320.00
Day 2: $1650.00
Day 3: $1078.00
Day 4: $1925.00
Day 5: $1210.00
Day 6: $1430.00
Day 7: $1760.00

Técnicas Clave de Cálculo con Arrays:

1. Cálculo de la Suma Total

   • Utiliza un bucle para sumar todos los elementos del array
   • Acumula los valores en una variable separada
   • Útil para encontrar la suma total

2. Cálculo del Promedio

   • Divide la suma total por el número de elementos
   • Utiliza la conversión de tipos para obtener precisión de punto flotante
   • Proporciona el valor medio de los elementos del array

3. Encontrar el Máximo/Mínimo

   • Inicializa con el primer elemento del array
   • Compara cada elemento subsiguiente
   • Actualiza el valor máximo/mínimo cuando se encuentra un nuevo extremo

4. Transformaciones Elemento a Elemento

   • Aplica operaciones matemáticas a cada elemento
   • Puedes modificar los valores del array según reglas específicas
   • Útil para escalar, ajustar o transformar datos

Principios Importantes de Cálculo:

• Siempre considera los límites del array
• Utiliza tipos de datos adecuados
• Ten cuidado con la división de enteros
• Inicializa las variables acumuladoras antes de realizar los cálculos

Asignar Memoria de Array de Forma Dinámica

En este paso, aprenderás cómo asignar memoria de forma dinámica para arrays en programación C utilizando las funciones malloc(), realloc() y free(). La asignación dinámica de memoria te permite crear arrays con tamaños determinados en tiempo de ejecución.

Creemos un nuevo archivo C para explorar la asignación dinámica de memoria:

cd ~/project
touch dynamic_array.c

Ahora, escribamos un programa que demuestre la asignación dinámica de memoria para arrays:

#include <stdio.h>
#include <stdlib.h>

int main() {
    // Asignación dinámica de memoria para un array de enteros
    int array_size;
    printf("Enter the number of elements: ");
    scanf("%d", &array_size);

    // Asignar memoria de forma dinámica
    int *dynamic_array = (int *)malloc(array_size * sizeof(int));

    // Verificar si la asignación de memoria fue exitosa
    if (dynamic_array == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // Ingresar elementos del array
    printf("Enter %d integers:\n", array_size);
    for (int i = 0; i < array_size; i++) {
        printf("Element %d: ", i + 1);
        scanf("%d", &dynamic_array[i]);
    }

    // Imprimir elementos del array
    printf("\nArray elements:\n");
    for (int i = 0; i < array_size; i++) {
        printf("%d ", dynamic_array[i]);
    }
    printf("\n");

    // Redimensionar el array de forma dinámica
    int new_size;
    printf("\nEnter new array size: ");
    scanf("%d", &new_size);

    // Volver a asignar memoria
    int *resized_array = (int *)realloc(dynamic_array, new_size * sizeof(int));

    // Verificar si la reasignación fue exitosa
    if (resized_array == NULL) {
        printf("Memory reallocation failed!\n");
        free(dynamic_array);
        return 1;
    }

    dynamic_array = resized_array;

    // Si el nuevo tamaño es mayor, inicializar nuevos elementos
    if (new_size > array_size) {
        for (int i = array_size; i < new_size; i++) {
            dynamic_array[i] = 0;
        }
    }

    // Imprimir el array redimensionado
    printf("Resized array:\n");
    for (int i = 0; i < new_size; i++) {
        printf("%d ", dynamic_array[i]);
    }
    printf("\n");

    // Liberar la memoria asignada dinámicamente
    free(dynamic_array);

    return 0;
}

Compila y ejecuta el programa:

gcc dynamic_array.c -o dynamic_array
./dynamic_array

Ejemplo de interacción:

Enter the number of elements: 3
Enter 3 integers:
Element 1: 10
Element 2: 20
Element 3: 30

Array elements:
10 20 30

Enter new array size: 5
Resized array:
10 20 30 0 0

Conceptos Clave de Asignación Dinámica de Memoria:

1. Función malloc()

   • Asigna la memoria solicitada y devuelve un puntero
   • Sintaxis: pointer = (type *)malloc(size * sizeof(type))
   • Siempre verifica si el puntero es NULL para asegurar una asignación exitosa

2. Función realloc()

   • Redimensiona un bloque de memoria previamente asignado
   • Puede aumentar o disminuir el tamaño del array
   • Conserva los datos existentes al expandir

3. Función free()

   • Desasigna la memoria asignada dinámicamente
   • Previene fugas de memoria
   • Debe llamarse para cada asignación realizada con malloc()/realloc()

Principios Importantes de Asignación de Memoria:

• Siempre verifica si la asignación fue exitosa
• Libera la memoria asignada dinámicamente cuando ya no la necesites
• Ten cuidado al redimensionar arrays
• Maneja adecuadamente los posibles fallos de asignación

Resumen

En este laboratorio, aprendiste cómo declarar e inicializar arrays en programación C, acceder y modificar elementos de arrays, iterar a través de arrays, realizar cálculos con arrays y asignar memoria de forma dinámica para arrays. Exploraste diferentes métodos para declarar e inicializar arrays, incluyendo especificar valores directamente, asignar valores posteriormente y inicializar parcialmente arrays. También aprendiste cómo imprimir el contenido de los arrays para verificar su inicialización. Estas operaciones fundamentales de arrays son esenciales para trabajar con estructuras de datos en C y constituyen los bloques de construcción para manipulaciones de arrays más complejas.