Dominando Estructuras en C: Gestión de Datos de Alumnos con Ejemplos Prácticos

Introducción al Manejo de Estructuras (struct) en C para Datos de Alumnos

Este documento ilustra cómo definir y operar con estructuras en el lenguaje de programación C, utilizando un ejemplo práctico de un registro de alumno. Se abordan la asignación de valores, la lectura desde la entrada estándar, la escritura en la salida estándar y el cálculo de un promedio.

Definición de la Estructura alum y Declaración de Variable

Primero, definimos una estructura llamada alum para almacenar la información de un alumno. Luego, declaramos una variable de este tipo llamada alumno.

struct alum {
    char nombre[20];
    long int cedula;
    char sec; // Sección del alumno (un solo carácter)
    int notas[11]; // Array para almacenar hasta 10 notas (usando índices 1-10)
};

struct alum alumno; // Declaración de una variable 'alumno' de tipo 'struct alum'

Nota sobre el array notas[11]: Este tamaño permite almacenar cómodamente 10 calificaciones utilizando los índices del 1 al 10, dejando el índice 0 sin usar en los ejemplos siguientes. Si se prefiriera usar índices del 0 al 9, el array podría declararse como int notas[10];.

Operaciones con el Registro alumno

1. Asignación Directa de Valores al Registro alumno

A continuación, se muestra cómo asignar valores específicos a los campos de la variable alumno directamente en el código. Los valores a asignar son:

• Nombre: Alfredo
• Cédula: 15.678.567 (este formato es para la descripción; en código C, los enteros no usan puntos)
• Sección: U
• Notas: 15 para cada una de las 10 calificaciones.

Código C para la asignación:

#include <string.h> // Necesario para la función strcpy()
#include <stdio.h>  // Necesario para printf() si se quiere verificar

// Asumiendo que 'alumno' y la estructura 'alum' ya están definidas y declaradas.
// Se necesitaría declarar la variable 'i' para el bucle, ej: int i;

strcpy(alumno.nombre, "Alfredo"); // Copia la cadena "Alfredo" al campo nombre
alumno.cedula = 15678567L;       // Asigna el número de cédula (L para long)
alumno.sec = 'U';                // Asigna el carácter 'U' a la sección

for (int i = 1; i <= 10; i++) { // Bucle para asignar 15 a las notas[1] hasta notas[10]
    alumno.notas[i] = 15;
}

2. Lectura de Datos para el Registro alumno desde Teclado

Este fragmento de código muestra cómo solicitar al usuario que ingrese los datos para el alumno (nombre, cédula y sección).

#include <stdio.h> // Necesario para printf(), scanf(), gets(), getchar()
// #include <string.h> // Necesario para strcspn si se usa para limpiar newline de fgets

// Asumiendo que 'alumno' y la estructura 'alum' ya están definidas y declaradas.

printf("Ingrese el nombre del alumno: ");
// La función gets() es insegura. Se recomienda usar fgets() en su lugar:
// fgets(alumno.nombre, sizeof(alumno.nombre), stdin);
// Para eliminar el carácter de nueva línea que fgets puede añadir:
// alumno.nombre[strcspn(alumno.nombre, "\n")] = 0;
gets(alumno.nombre); // Código original, mantener con precaución

printf("Ingrese la cédula del alumno (número entero largo): ");
scanf("%ld", &alumno.cedula);
while(getchar() != '\n'); // Limpiar el búfer de entrada para consumir el newline restante

printf("Ingrese la sección del alumno (un solo carácter): ");
scanf(" %c", &alumno.sec); // El espacio antes de %c ignora espacios/newlines previos
while(getchar() != '\n'); // Limpiar el búfer de entrada

Advertencia sobre gets(): La función gets() es peligrosa y ha sido deprecada en estándares C recientes porque no comprueba los límites del búfer de destino, lo que puede causar desbordamientos de búfer (buffer overflows), una grave vulnerabilidad de seguridad. Es altamente recomendable sustituir gets(alumno.nombre); por fgets(alumno.nombre, sizeof(alumno.nombre), stdin); y, si es necesario, eliminar el carácter de nueva línea (\n) que fgets podría incluir.

Corrección en scanf para la sección: El código original podría haber tenido scanf("%s", &alumno.sec);. Dado que sec es un char individual (no una cadena), el especificador de formato correcto es %c. El espacio antes de " %c" es una buena práctica para que scanf omita cualquier carácter de espacio en blanco (como espacios, tabulaciones o el \n) que haya quedado en el búfer de entrada de una llamada anterior a scanf o gets.

Limpieza del Búfer de Entrada: Después de usar scanf para leer números o caracteres, es común que el carácter de nueva línea (\n), ingresado cuando el usuario presiona Enter, permanezca en el búfer de entrada. Esto puede causar problemas con lecturas subsiguientes. El bucle while(getchar() != '\n'); es una forma de "limpiar" o "vaciar" el búfer de estos caracteres residuales.

3. Escritura (Visualización) de los Datos del Registro alumno

Una vez que el registro alumno tiene datos (ya sea por asignación directa o por lectura), podemos mostrarlos en la consola.

#include <stdio.h> // Necesario para printf()

// Asumiendo que 'alumno' tiene datos y la variable 'i' está declarada (ej: int i;)

printf("\n--- Datos del Alumno ---\n");
printf("Nombre del alumno: %s\n", alumno.nombre);
printf("Cédula del alumno: %ld\n", alumno.cedula); // Usar %ld para long int
printf("Sección del Alumno: %c\n", alumno.sec);

printf("Notas:\n");
for (int i = 1; i <= 10; i++) { // Muestra las notas de notas[1] a notas[10]
    printf("Nota #%d: %d\n", i, alumno.notas[i]);
}

4. Cálculo del Promedio del Campo notas

Finalmente, calculamos el promedio de las calificaciones almacenadas en el campo notas del registro alumno.

#include <stdio.h> // Para printf() si se quiere mostrar el promedio

// Asumiendo que 'alumno' tiene las notas cargadas.
// Se deben declarar 'suma' y 'prom'.

int suma = 0;
float prom = 0.0f; // Usar float para el promedio para obtener decimales
int cantidad_notas = 10; // Número de notas a promediar

// Sumar las notas (asumiendo que son las 10 notas de los índices 1 a 10)
for (int i = 1; i <= cantidad_notas; i++) {
    suma = suma + alumno.notas[i];
}

// Calcular el promedio
if (cantidad_notas > 0) {
    prom = (float)suma / cantidad_notas; // Casting a float para asegurar división decimal
} else {
    prom = 0.0f; // Evitar división por cero si no hay notas
}

// Opcional: Mostrar el promedio
// printf("El promedio de las notas es: %.2f\n", prom);

Nota: Es importante declarar la variable suma (como int) y prom (preferiblemente como float o double para permitir decimales en el promedio). La expresión (float)suma / cantidad_notas asegura que se realice una división de punto flotante, resultando en un promedio más preciso.