Laboratorio 8

#include <stdio.h>

typedef unsigned char uint8_t;
typedef signed char int8_t;
typedef unsigned short int uint16_t;
typedef char* string;

int main(void)
{
    uint8_t a = 0xFF;
    int8_t b = 0xFF;
    uint16_t c = 0xFFFF;
    string texto = "hola mundo\n";

    printf("Testeando tipos de datos, haremos todos los bits = 1:\n");
    printf("uint8_t el tamano es: %zu bytes y el valor obtenido es %d\n", sizeof(uint8_t), a);
    printf("int8_t el tamano es: %zu bytes y el valor obtenido es %d\n", sizeof(int8_t), b);
    printf("uint16_t el tamano es: %zu bytes y el valor obtenido es %d\n", sizeof(uint16_t), c);
    printf("\nProbando el tipo string, el string contiene %s", texto);

    return 0;

}

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

typedef struct {
    char* nombre;
    char* apellido;
    unsigned int matricula;
    float nota;
} Alumno;

void imprimir_alumno(Alumno a)
{
    printf("%s %s %d %.2f\n", a.nombre, a.apellido, a.matricula, a.nota);
}

int main(void)
{
    Alumno alumno_1 = { "Diego", "Palma", 2008404166, 7.0 };
    Alumno alumno_2;

    alumno_2.nombre = malloc(sizeof(char)*20);
    alumno_2.apellido = malloc(sizeof(char)*20);

    printf("Ingrese alumno: (nombre apellido matricula nota)\n");
    scanf("%s %s %d %f", alumno_2.nombre, alumno_2.apellido, &alumno_2.matricula, &alumno_2.nota);

    // Imprimir los dos alumnos
    imprimir_alumno(alumno_1);
    imprimir_alumno(alumno_2);

    free(alumno_2.nombre);
    free(alumno_2.apellido);
    return 0;
}

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

typedef struct {
    char* nombre;
    char* apellido;
    unsigned int matricula;
    float nota;
} Alumno;

void imprimir_alumno(Alumno a)
{
    printf("%s %s %d %.2f\n", a.nombre, a.apellido, a.matricula, a.nota);
}

int main(void)
{
    Alumno alumno_1 = { "Diego", "Palma", 2008404166, 7.0 };
    Alumno alumno_2;

    alumno_2.nombre = malloc(sizeof(char)*20);
    alumno_2.apellido = malloc(sizeof(char)*20);

    printf("Ingrese alumno 2: (nombre apellido matricula nota)\n");
    scanf("%s %s %d %f", alumno_2.nombre, alumno_2.apellido, &alumno_2.matricula, &alumno_2.nota);


    Alumno *ptrAlumno = malloc(sizeof(Alumno));
    ptrAlumno->nombre = malloc(sizeof(char)*20);
    ptrAlumno->apellido = malloc(sizeof(char)*20);

    printf("Ingrese alumno 3: (nombre apellido matricula nota)\n");
    scanf("%s %s %d %f", ptrAlumno->nombre, ptrAlumno->apellido, &ptrAlumno->matricula, &ptrAlumno->nota);


    // Imprimir los tres alumnos
    imprimir_alumno(alumno_1);
    imprimir_alumno(alumno_2);
    imprimir_alumno(*ptrAlumno);

    // Liberar memoria requerida para el alumno 2
    free(alumno_2.nombre);
    free(alumno_2.apellido);

    // Liberar memoria requerida para el alumno 3
    free(ptrAlumno->nombre);
    free(ptrAlumno->apellido);
    free(ptrAlumno);
    return 0;
}

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

typedef struct {
    char* nombre;
    char* apellido;
    unsigned int matricula;
    float nota;
} Alumno;

/**
 * Funcion para imprimir un dato del tipo alumno
 */
void imprimir_alumno(Alumno a)
{
    printf("Nombre\t\t: %s\n", a.nombre);
    printf("Apellido\t: %s\n", a.apellido);
    printf("Matricula\t: %d\n", a.matricula);
    printf("Nota\t\t: %.2f\n", a.nota);
}

/**
 * Retorna un alumno ingresado por teclado.
 */
Alumno ingresar_alumno()
{
    Alumno a;

    // Pedir memoria para guardar nombre y apellido. Por simplicidad no chequearemos malloc.
    a.nombre = malloc(sizeof(char)*20);
    a.apellido = malloc(sizeof(char)*20);

    scanf("%s %s %d %f", a.nombre, a.apellido, &a.matricula, &a.nota);
    return a;
}

/**
 * Funcion que retorna string diciendo si el alumno aprueba o reprueba y su nota.
 */
char* aprobado(Alumno* a)
{
    char* string = malloc(80*sizeof(char));

    if (a->nota >= 4.0)
        sprintf(string, "El alumno %s %s aprobo el curso con un %.2f", a->nombre, a->apellido, a->nota);
    else
        sprintf(string, "El alumno %s %s reprobo el curso con un %.2f", a->nombre, a->apellido, a->nota);

    return string;
}

/**
 * Dada una lista de alumnos, escribe en un archivo txt los strings
 * retornados por la funcion aprobado(), para cada alumno de la lista.
 */
int escribirAprobado(Alumno* alumnos, int n)
{
    // Abrir archivo para escritura como texto.
    FILE* archivo = fopen("Aprobado.txt", "wt");

    if (archivo == NULL) return -1;

    int i;
    for (i = 0; i < n; i++)
    {
        char* msje = aprobado(&alumnos[i]);
        fprintf(archivo, "%s\n", msje);
        free(msje);
    }

    fclose(archivo);
    return 0;
}

/**
 * Dada una lista de alumnos, guarda en un archivo binario
 * los datos de los alumnos
 */
int escribirDatosAlumnos(Alumno* alumnos, int n)
{
    // Abrir archivo para escritura en binario
    FILE* archivo = fopen("DatosAlumnos.bin", "wb");

    if (archivo == NULL) return -1;

    fwrite(&n, sizeof(int), 1, archivo);
    int i;
    for (i = 0; i < n; i++)
    {
        /* Si queremos guardar "buffers" dinamicos, necesitamos guardar antes el tamanho.
         * Generalmente es buena practica guardar buffers estaticos para que el binario tenga
         * El mismo tamanho siempre. 
         */
        int len = strlen(alumnos[i].nombre) + 1;
        fwrite(&len, sizeof(len), 1, archivo);
        fwrite(alumnos[i].nombre, sizeof(char), len, archivo);
        len = strlen(alumnos[i].apellido) + 1;
        fwrite(&len, sizeof(len), 1, archivo);
        fwrite(alumnos[i].apellido, sizeof(char), len, archivo);
        fwrite(&alumnos[i].matricula, sizeof(int), 1, archivo);
        fwrite(&alumnos[i].nota, sizeof(float), 1, archivo);
    }

    // Finalmente debe cerrarse el archivo.
    fclose(archivo);
    return 0;
}

void liberar_memoria(Alumno* alumnos, int n)
{
    int i;
    for (i = 0; i < n; i++)
    {
        free(alumnos[i].nombre);
        free(alumnos[i].apellido);
    }
    free(alumnos);
}

int main(void)
{

    // Pedir memoria para 5 alumnos
    Alumno *alumnos = malloc(sizeof(Alumno)*5);

    // Si no hay memoria disponible...
    if (alumnos == NULL) return 1;

    int i;
    for (i = 0; i < 5; i++)
    {
        printf("Ingrese Alumno %d: ( nombre apellido matricula nota )\n", i + 1);
        alumnos[i] = ingresar_alumno();
        printf("Datos del alumno %d\n", i + 1);
    }

    for (i = 0; i < 5; i++)
    {
        imprimir_alumno(alumnos[i]);
        printf("\n");
    }

    for (i = 0; i < 5; i++)
    {
        char* mensaje = aprobado(&alumnos[i]);
        printf("%s\n", mensaje);
        free(mensaje);
    }

    // Debiesemos chequear los valores retornados por las funciones
    // No se hara por simplicidad.
    escribirAprobado(alumnos, 5);
    escribirDatosAlumnos(alumnos, 5);
    liberar_memoria(alumnos, 5);

    return 0;
}

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

int main(void)
{
    FILE *archivo = fopen("Aprobado.txt", "rt");

    if (archivo == NULL)
    {
        printf("No se pudo abrir archivo.\n");
        return 1;
    }

    char buffer[80];
    while (fgets(buffer, 80, archivo))
    {
        printf("%s", buffer);
    }

    fclose(archivo);
    return 0;
}

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

typedef struct {
    char* nombre;
    char* apellido;
    unsigned int matricula;
    float nota;
} Alumno;

/**
 * Funcion para imprimir un dato del tipo alumno
 */
void imprimir_alumno(Alumno a)
{
    printf("Nombre\t\t: %s\n", a.nombre);
    printf("Apellido\t: %s\n", a.apellido);
    printf("Matricula\t: %d\n", a.matricula);
    printf("Nota\t\t: %.2f\n", a.nota);
}

void liberar_memoria(Alumno* alumnos, int n)
{
    int i;
    for (i = 0; i < n; i++)
    {
        free(alumnos[i].nombre);
        free(alumnos[i].apellido);
    }
    free(alumnos);
}

int main(void)
{
    FILE* archivo = fopen("DatosAlumnos.bin", "rb");

    if (archivo == NULL) return 1;

    // Los archivos deben ser leidos de la misma forma en que fueron escritos
    int i, n;
    fread(&n, sizeof(int), 1, archivo);

    Alumno *alumnos = malloc(sizeof(Alumno)*n);
    if (alumnos == NULL) return 1;

    for (i = 0; i < n; i++)
    {
        int len, j;
        fread(&len, sizeof(int), 1, archivo);
        alumnos[i].nombre = malloc(sizeof(char)*len);
        fread(alumnos[i].nombre, sizeof(char), len, archivo);
        fread(&len, sizeof(int), 1, archivo);
        alumnos[i].apellido = malloc(sizeof(char)*len);
        fread(alumnos[i].apellido, sizeof(char), len, archivo);
        fread(&alumnos[i].matricula, sizeof(int), 1, archivo);
        fread(&alumnos[i].nota, sizeof(float), 1, archivo);
    }

    for (i = 0; i < 5; i++)
    {
        imprimir_alumno(alumnos[i]);
        printf("\n");
    }

    liberar_memoria(alumnos, n);
    fclose(archivo);
}

#include <stdio.h>
#include <math.h>

typedef struct {
    float x;
    float y;
} Punto;

int main(void)
{
    Punto p1 = { 2, 3}, p2 = { 4, 6 };

    printf("Calculemos la distancia entre puntos en un plano:\n\n");
    printf("1) punto 1: x = %.2f\t y = %.2f\n", p1.x, p1.y);
    printf("2) punto 2: x = %.2f\t y = %.2f\n", p2.x, p2.y);

    printf("\nPor lo tanto la distancia entre ambos puntos es: %.2f\n",
            sqrt(pow(p1.x-p2.x, 2) + pow(p1.y-p2.y, 2)));

    return 0;
}