Clase de ICC-103 - 8/03/2022

main.c

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

typedef struct {
    char clave[4];
    char nombre[100];
} Carrera;

typedef struct {
    int id; //4 byte
    char nombre[100]; //100 byte
    Carrera carrera; //104 byte //puedo incluir cualquier tipo incluyendo otra estructura
} Estudiante; //208 bytes

typedef struct {
    int numero; //4 byte
    int cantidad_estudiante; //4 bytes
    Estudiante *estudiantes; // 8 bytes. //asignación dinámica.. en cantidad_estudiante tengo la cantidad de estudiante asociado.
} GrupoClase;

void clearBuffer();
void registro_carreras();
Carrera dato_carrera_stdin();
void imprimir_carrera(Carrera carrera);
void imprimir_arreglo_carrera(Carrera *arreglo, int cantidad);
Estudiante dato_estudiante_stdin();
void imprimir_estudiante(Estudiante estudiante);
void imprimir_arreglo_estudiante(Estudiante *arreglo, int cantidad);
void asociar_carrera_estudiante(int id,
                                Estudiante *arreglo_estudiante,
                                int cantidad_estudiante,
                                Carrera *arreglo_carrrera,
                                int cantidad_carrrera);
Estudiante* datos_estudiante_por_id(int id, Estudiante *arreglo_estudiante, int cantidad_estudiante);
void ejercicio_estructura();
//Estudiante informacion_estudiante_por_id_stdin();
GrupoClase* datos_grupo_clase_stdin();
void imprimir_grupo_clase(GrupoClase *grupoClase);
void liberarGrupoClase(GrupoClase *grupoClase);

int main() {

    //void* malloc(sizeof); //colocacion, bloque de memoria solicitada.
    //void* calloc(int cantidadm sizeof elemento); //mismo que malloc, limpiando la información del bloque retornado.
    //void* realloc(void * puntero, size_t);
    //free(void *)

    //
    //void *pGenerico = calloc(2, sizeof(Estudiante)); //
    //Estudiante *estudiantes = (Estudiante *) pGenerico; // casting o conversion de tipo.
    int cantidad = 0;
    printf("Digite la cantidad de estudiante: ");
    scanf("%d", &cantidad);
    clearBuffer();

    //
    Estudiante *estudiantes =  (Estudiante *) calloc(cantidad, sizeof(Estudiante)); //
    if(estudiantes == NULL){
        printf("Si memoria para asignar");
        return -1;
    }
    for (int i = 0; i < cantidad; ++i) {
        estudiantes[i] = dato_estudiante_stdin();
    }
    imprimir_arreglo_estudiante(estudiantes, cantidad);

    //incrementando la cantidad de estudiante.
    int incremento = 0;
    printf("Digite la cantidad de estudiante a incrementar: ");
    scanf("%d", &incremento);
    clearBuffer();

    //aumentar la memoria.
    estudiantes = (Estudiante *) realloc(estudiantes, sizeof(Estudiante) * (cantidad+incremento));
    if(estudiantes == NULL){
        printf("Si memoria para asignar");
        return -1;
    }
    for (int i = cantidad; i < (cantidad+incremento); ++i) {
        estudiantes[i] =dato_estudiante_stdin();
    }
    imprimir_arreglo_estudiante(estudiantes, cantidad+incremento);

    //devolver la memoria.
    free(estudiantes);

    //Asignación de memoria dinámica para entero.
    int *enteros = malloc(sizeof(int) * 4);
    if(enteros == NULL){
        return -1; //no tengo memoria.
    }
    for (int i = 0; i < 4; ++i) {
        *(enteros+i) = i+1; //?
    }
    for (int i = 0; i < 4; ++i) {
        printf("entero[%d] = %d\n", i,enteros[i]);
    }
    free(enteros);

    //Cadenas.
    char *cadenas = calloc(100, sizeof(char ));
    if(cadenas == NULL){
        return -1; //no tengo memoria.
    }
    strcpy(cadenas, "Cadena con asignación de memoria dinámica...."); // debo tener memoria para \0, 99 posiciones.
    printf("La cadena = %s\n", cadenas);
    free(cadenas);

    printf("La cantidad de memoria ocupada de GrupoClase: %d bytes\n", sizeof(GrupoClase));
    GrupoClase *grupoClase = datos_grupo_clase_stdin();
    imprimir_grupo_clase(grupoClase);
    //liberar la memoria.
    //free(grupoClase); // no estoy liberando la lista de estudiante... Memory Leak!.
    liberarGrupoClase(grupoClase);

    //grupoClase = datos_grupo_clase_stdin(); //Memory Leak, perdí la referen del puntero anterior.
    //grupoClase = datos_grupo_clase_stdin();

    return 0;
}



/**
 *
 * @return
 */
GrupoClase* datos_grupo_clase_stdin(){
    // Para simplificar creo el número directo.
    GrupoClase *grupoClase = (GrupoClase *) calloc(1, sizeof(GrupoClase));
    if(grupoClase == NULL){
        return NULL;
    }
    grupoClase->numero= 6585;

    //Solicitando la cantida de estudiante.
    int cantidad = 0;
    printf("Digite la cantidad de estudiante: ");
    scanf("%d", &cantidad);
    clearBuffer();

    //
    Estudiante *estudiantes =  (Estudiante *) calloc(cantidad, sizeof(Estudiante)); //
    if(estudiantes == NULL){
        printf("Si memoria para asignar");
        return NULL;
    }
    for (int i = 0; i < cantidad; ++i) {
        estudiantes[i] = dato_estudiante_stdin();
    }

    //asignacion de los estudiantes.
    grupoClase->estudiantes = estudiantes;
    grupoClase->cantidad_estudiante = cantidad;

    //
    return grupoClase;
}

void liberarGrupoClase(GrupoClase *grupoClase){
    if(grupoClase->estudiantes != NULL) {
        free(grupoClase->estudiantes); //libero la asignación memoria de los estudiantes.
    }
    free(grupoClase); //libero la memoria del grupo de clase.
}

void imprimir_grupo_clase(GrupoClase *grupoClase){
    printf("Grupo de Clase #%d\n", grupoClase->numero);
    if(grupoClase->estudiantes == NULL ){
        printf("Sin estudiantes");
    }else{
        for (int i = 0; i < grupoClase->cantidad_estudiante; ++i) {
            printf("\t");
            imprimir_estudiante(grupoClase->estudiantes[i]);
        }
    }
}

void ejercicio_estructura(){
    printf("Ejercicio sobre Estructuras\n");
    //
    Carrera arreglo_carrera_opcion1[10]; //opción #1
    Estudiante arreglo_estudiante_opcion1[10]; //opción #1
    int cantidad_carrera;
    int cantidad_estudiante;
    //
    printf("Digite la cantidad de Carreras (Maximo 10):");
    scanf("%d", &cantidad_carrera); //TODO: Validar que no pase de 10 elementos.
    clearBuffer();
    printf("Cantidad Carreras Digitadas: %d\n", cantidad_carrera);
    //crear la arreglo en ejecución
    Carrera arreglo_carrera_opcion2[cantidad_carrera]; //opción #2
    /*Carrera carrera = dato_carrera_stdin();
    imprimir_carrera(carrera);*/
    //Registrar las carreras en función a la cantidad indicada.
    for (int i = 0; i < cantidad_carrera; ++i) {
        printf("Carrera [%d]:\n", i+1);
        arreglo_carrera_opcion2[i] = dato_carrera_stdin();
    }
    // Imprimir el arreglo de las carreras.
    imprimir_arreglo_carrera(arreglo_carrera_opcion2, cantidad_carrera);
    printf("Digite la cantidad de Estudiante (Maximo 10):");
    scanf("%d", &cantidad_estudiante); //TODO: Validar que no pase de 10 elementos.
    clearBuffer();
    printf("Cantidad Estudiante Digitadas: %d\n", cantidad_estudiante);
    Estudiante arreglo_estudiante_opcion2[cantidad_estudiante]; //opción #2
    //Registrar los estudiantes en función a la cantidad indicada.
    for (int i = 0; i < cantidad_estudiante; ++i) {
        printf("Estudiante [%d]:\n", i+1);
        arreglo_estudiante_opcion2[i] = dato_estudiante_stdin();
    }
    //Imprime el arreglo de estudiante almacenado.
    imprimir_arreglo_estudiante(arreglo_estudiante_opcion2, cantidad_estudiante);
    /* //Prueba de busqueda de estudiante por ID.
     Estudiante *ref_estudiante = datos_estudiante_por_id(20011136, arreglo_estudiante_opcion2, cantidad_estudiante);
     if(ref_estudiante != NULL){
         printf("Estudiante encontrado\n");
         imprimir_estudiante(*ref_estudiante);
     }else{
         printf("Estudiante no encontrado.\n");
     }*/
    int id;
    printf("Indicar el ID Estudiante:");
    scanf("%d", &id);
    clearBuffer();
    //
    asociar_carrera_estudiante(id, arreglo_estudiante_opcion2, cantidad_estudiante, arreglo_carrera_opcion2, cantidad_carrera);
    //
    imprimir_arreglo_estudiante(arreglo_estudiante_opcion2, cantidad_estudiante);
}
void asociar_carrera_estudiante(int id,
                                Estudiante *arreglo_estudiante,
                                int cantidad_estudiante,
                                Carrera *arreglo_carrrera,
                                int cantidad_carrrera){
    //
    Estudiante *ref_estudiante = datos_estudiante_por_id(id, arreglo_estudiante, cantidad_estudiante);
    //validando que exista el estudiante.
    if(ref_estudiante == NULL){
        printf("No existe el estudiante con iD: %d\n", id);
        return;
    }
    //tengo la referencia del estudiante con el ID.
    printf("Las Carreras Registradas:\n");
    imprimir_arreglo_carrera(arreglo_carrrera, cantidad_carrrera);
    //asociacion.
    int posicion_carrera;
    printf("Indique la posicion:");
    scanf("%d", &posicion_carrera);
    //TODO: validar que el valor sea el rango permitido.
    Carrera carrera = arreglo_carrrera[posicion_carrera];
    ref_estudiante->carrera = carrera;
}
/**
 *
 * @param id
 * @param arreglo_estudiante
 * @param cantidad_estudiante
 * @return
 */
Estudiante* datos_estudiante_por_id(int id, Estudiante *arreglo_estudiante, int cantidad_estudiante){
    Estudiante* estudiante_encontrado = NULL;
    for (int i = 0; i < cantidad_estudiante; ++i) {
        if(arreglo_estudiante[i].id == id){ //encontre el estudiante
            //estudiante_encontrado = &arreglo_estudiante[i];
            estudiante_encontrado = arreglo_estudiante+i;
            break;
        }
    }
    return estudiante_encontrado;
}
Estudiante dato_estudiante_stdin(){
    Estudiante estudiante = {0}; //
    printf("ID:");
    scanf("%d", &estudiante.id);
    clearBuffer();
    printf("Nombre:");
    fgets(estudiante.nombre, 100, stdin);
    //TODO: limpiar el cambio de linea en nombre.
    //clearBuffer();
    return estudiante;
}
/**
 *
 * @return
 */
Carrera dato_carrera_stdin(){
    Carrera carrera;
    printf("Clave:");
    fgets(carrera.clave, 4, stdin);
    clearBuffer();
    printf("Nombre:");
    fgets(carrera.nombre, 100, stdin);
    //TODO: limpiar el cambio de linea en nombre.
    //clearBuffer();
    return carrera;
}
void imprimir_estudiante(Estudiante estudiante){
    printf("Estudiante: {Id: %d, Nombre: %s, Carrera: {Clave: %s, Nombre: %s} }\n",
           estudiante.id, estudiante.nombre, estudiante.carrera.clave, estudiante.carrera.nombre);
}
void imprimir_arreglo_estudiante(Estudiante *arreglo, int cantidad){
    for (int i = 0; i < cantidad; ++i) {
        imprimir_estudiante(arreglo[i]);
    }
}
void imprimir_arreglo_carrera(Carrera *arreglo, int cantidad){
    for (int i = 0; i < cantidad; ++i) {
        imprimir_carrera(arreglo[i]);
    }
}
void imprimir_carrera(Carrera carrera){
    printf("{ Clave: %s, Nombre: %s} \n", carrera.clave, carrera.nombre);
}
void clearBuffer(){
    int c;
    while ((c = getchar()) != '\n' && c != EOF) {
    }
    return;
}