Ejercicio obligatorio 3

Fecha de entrega: Domingo 6 de junio

Introducción

Queremos modelar un polígono, para ello definimos la estructura:

typedef struct {
    float (*vertices)[2];
    size_t n;
} poligono_t;

que permite almacenar en memoria un polígono según el siguiente esquema:

Trabajo

Creación y destrucción

Se pide implementar la función poligono_t *poligono_crear(float vertices[][2], size_t n); que cree un nuevo polígono en base a los n vertices recibidos. La función debe devolver el polígono creado en memoria nueva o NULL en caso de falla.

Se pide implementar la función void poligono_destruir(poligono_t *poligono); que libere la memoria asociada al poligono previamente creado.

Getters

Se pide implementar la función size_t poligono_cantidad_vertices(const poligono_t *poligono); que devuelva la cantidad de vértices en el poligono recibido.

Se pide implementar la función bool poligono_obtener_vertice(const poligono_t *poligono, size_t pos, float *x, float *y); que devuelva por la interfaz las coordenadas (x, y) del vértice que está en la posición pos de poligono. La función debe retornar true de poder completar la operación, false en caso contrario.

Memoria

Implementar la función poligono_t *poligono_clonar(const poligono_t *poligono); que dado un poligono devuelva la copia del mismo en memoria nueva.

Implementar la función bool poligono_agregar_vertice(poligono_t *poligono, float x, float y); que agregue el punto de coordenadas (x, y) al final del poligono recibido. En caso de falla debe dejarse inalterado el poligono recibido y devolver false, se devuelve true en caso contrario.

Aplicación y validación

Se provee el siguiente main() que implementa una serie de pruebas:

int main(void) {
    float puntos[3][2] = {{0, 0}, {1, 0}, {0, 1}};

    poligono_t *p1 = poligono_crear(puntos, 3);
    if(p1 == NULL) {
        fprintf(stderr, "Error en creacion de poligono\n");
        return 1;
    }

    float x, y;

    assert(poligono_cantidad_vertices(p1) == 3);
    assert(! poligono_obtener_vertice(p1, 3, &x, &y));
    assert(poligono_obtener_vertice(p1, 1, &x, &y));
    assert(x == 1 && y == 0);

    poligono_t *p2 = poligono_clonar(p1);
    poligono_destruir(p1);
    if(p2 == NULL) {
        fprintf(stderr, "Error en creacion de poligono\n");
        return 1;
    }

    assert(poligono_cantidad_vertices(p2) == 3);
    assert(poligono_obtener_vertice(p2, 2, &x, &y));
    assert(x == 0 && y == 1);

    assert(poligono_agregar_vertice(p2, -1, 0.5));
    assert(poligono_cantidad_vertices(p2) == 4);
    assert(poligono_obtener_vertice(p2, 3, &x, &y));
    assert(x == -1 && y == 0.5);

    poligono_destruir(p2);

    assert(poligono_crear(puntos, ~0UL) == NULL);

    return 0;
}

El mismo debe ser utilizado y debe verificarse que funcione correctamente y sin fugas de memoria.

Este main(), sin alteraciones, debe ser entregado como parte del ejercicio.

Entrega

Deberá entregarse el código fuente del programa desarrollado.

El programa debe:

1. Compilar correctamente con los flags:

   -Wall -Werror -std=c99 -pedantic
   

2. pasar Valgrind correctamente,

3. validar las pruebas dadas.

La entrega se realiza a través del sistema de entregas.

El ejercicio es de entrega individual.