aula12

Author: flubacheski

content/aulas/12-tipos-de-dados/index.md

@@ -0,0 +1,130 @@
+# 12 - Tipos abstratos de dados
+
+!!! pdf
+    ![](slides.pdf)
+
+<br>
+## A estrutura `Point2D`
+
+Vamos considerar primeiro uma estrutura usada para guardar um ponto 2D. Este tipo de estrutura seria útil ao trabalhar com algoritmos de Geometria Computacional ou mesmo em aplicações de física.
+
+~~~{.C}
+typedef struct {
+    double x, y;
+} Point2D;
+~~~
+
+Vamos listar algumas operações que podem ser feitas com um ponto:
+
+1. Inicialização e finalização - todo ponto deve ser inicializado com algum valor para x e y.
+1. Somar dois pontos (e obter um terceiro);
+1. Calcular o coeficiente angular de uma reta que passe pelos dois pontos;
+1. Multiplicar ambas as coordenadas de um ponto (recebendo um novo em troca) - esta operação equivale a mudanças de escala
+1. Retornar os valores das componentes x e y do ponto;
+
+A ideia de um *Tipo Abstrato de Dados* é formalizar um "contrato" que lista quais operações podem ser feitas com este dado. Estas operações não dependem de nenhuma implementação em particular do tipo. Por exemplo, declarar o ponto com contendo um `double coords[2]` não muda os resultados de nenhuma das operações acima mas mudaria o código de acesso a coordenada `x` (`p.x` vs `p.coords[0]`). Veja um exemplo concreto de como fazer isto abaixo (arquivo *point2d.h*).
+
+```c
+#ifndef __POINT2D__
+#define __POINT2D__
+
+typedef struct{
+    double x, y;
+}Point2D;
+
+Point2D *point2D_new(double x, double y);
+void point2D_destroy(Point2D *p);
+
+double point2D_get_x(Point2D *p);
+double point2D_get_y(Point2D *p);
+
+Point2D *point2D_add(Point2D *p1, Point2D *p2);
+double point2D_theta(Point2D *p1, Point2D *p2);
+Point2D *point2D_scale(Point2D *p, double s);
+
+#endif
+```
+
+!!! Note "Declarando tipos abstratos"
+    Em *C* declaramos os **tipos abstratos de dados** e as **funções**  que podem ser usadas por outras partes do código em arquivos `.h` e implementamos essas funções em arquivos `.c` (de mesmo nome, muitas vezes). Assim conseguimos organizar nosso código em vários módulos e depois juntá-los no momento da compilação. 
+
+Notem que essa lista de operações "toma conta" da alocação e liberação de memória. Ou seja, o usuário de nosso `Point2D` não precisa se preocupar com malloc ou free. Basta que ele chame nossas funções.
+
+!!! Note "Por que todas as funções começam com `point2D_` ?"
+    Em *C* não existe o conceito de módulo, namespace ou qualquer outro tipo de mecanismo de importar código. Toda função, a princípio, é declarada no escopo global de nomes. Isso significa que se nomeássemos `point2D_add` simplesmente como `add` nenhuma outra função escrita, por nós ou de nenhuma outra biblioteca usada no nosso programa, poderia ter esse nome.
+
+    A estratégia usada nesse caso, é usar um prefixo que indique a qual biblioteca a função pertence. No nosso caso, usamos `point2D_` em todas as funções para evitar colisões de nomes. 
+    
+
+## Acessando as informações do Tipo Abstrato de Dados
+
+Note que na declaração das funções, algumas retornam um ponteiro para o Tipo Abstrato de Dados `Point2D` ou recebem como parâmetro um ponteiro para esse tipo, em ambos os casos o ponteiro foi **alocado dinamicamente na memória**. Para acessar as variáveis do tipo `Point2D`  (`x` ou `y`) devemos usar o operador `->`. Por exemplo se temos uma variável `Point2D *p`, o acesso à `x` deve ser da seguinte forma `p->x`.
+
+!!! example
+    Abra o arquivo `test_point2d.c`. Você consegue entender seu conteúdo? Examine o código e entenda como `Point2D` deve ser usado.
+
+!!! exercise text short
+    Compile o arquivo `test_point2d.c` usando a seguinte linha de comando. Rode-o logo em seguida. O que significa sua saída?
+
+    <div class="termy">
+
+    ```console
+    $ gcc -Og -Wall -g test_point2d.c point2d.c -o teste_ponto
+    ```
+
+    </div>
+
+
+    Responda aqui:
+    !!! answer
+        São realizadas chamadas de testes automáticos que tentam utilizar as funcionalidade de `Point2D`. Os testes falham porque as implementações não foram realizadas.
+
+!!! example
+    Abra o arquivo `point2d.c` e complete as partes faltantes. Verifique se tudo funciona corretamente usando `test_point2d.c`. Você deve aproveitar ao máximo as funções já criadas (ou seja, pode usar `point2d_new` nas outras funções).
+
+!!! example
+    Agora que sua implementação do *TAD* `Point2D` está completa, compile o arquivo `test_point2d.c` e execute-o usando o *Valgrind*. Seu programa deverá rodar sem erros.
+
+## Vetores dinâmicos
+
+!!! warning "Atividade para Entrega"
+    Os arquivos estão na pasta `09-tad` do repositório de entregas.
+
+!!! tip "Dica!"
+    Veja a explicação sobre a atividade no final dos slides dessa aula e não se esqueça de ler o `README.md` dentro da pasta `09-tad`!
+
+Agora que já vimos vetores dinâmicos em aula, vamos implementá-los. Nosso vetor tem a seguinte interface:
+
+```c
+#ifndef __VECINT_H__
+#define __VECINT_H__
+
+typedef struct{
+    int *data;
+    int size;
+    int capacity;
+}vec_int;
+
+vec_int *vec_int_create();
+void vec_int_destroy(vec_int **v);
+
+int vec_int_size(vec_int *v);
+
+/* As seguinte operações devolvem
+ * 1 se pos é uma posição válida e a operação foi bem sucedida
+ * 0 caso contrário
+ *
+ * No caso de at, o valor é retornado na variável apontada por vi.
+ */
+int vec_int_at(vec_int *v, int pos, int *vi);
+int vec_int_insert(vec_int *v, int pos, int val);
+int vec_int_remove(vec_int *v, int pos);
+
+#endif
+```
+
+!!! example
+    **Entrega**: implemente a estrutura *vetor dinâmico* no arquivo *vec_int.c* e compile o programa de forma semelhante como foi feito na parte anterior. Para sua entrega estar 100% seu programa de testes deverá rodar sem erros no *valgrind*.
+
+!!! tip "Dica!"
+    Leia os testes para entender as operações realizadas e os resultados esperados!

content/aulas/12-tipos-de-dados/mintest/macros.h

@@ -0,0 +1,17 @@
+#include <stdio.h>
+
+typedef int (*test_func)();
+
+typedef struct {
+    char name[50];
+    test_func function;
+} test_data;
+
+#define test_printf (printf("%s: ", __func__));printf
+
+#define test_assert(expr, str) { if(!(expr)) { printf("%s: [FAIL] %s in %s:%d\n", __func__, str, __FILE__, __LINE__); return -1; } }
+
+#define TEST(f) {.name=#f, .function=f}
+
+#define test_list test_data all_tests[]
+

content/aulas/12-tipos-de-dados/mintest/runner.h

@@ -0,0 +1,18 @@
+
+
+int main() {
+    int size = sizeof(all_tests)/sizeof(test_data);
+    printf("Running %d tests:\n", size);
+    printf("=====================\n\n");
+    int pass_count = 0;
+    for (int i = 0; i < size; i++) {
+        if (all_tests[i].function() >= 0) {
+            printf("%s: [PASS]\n", all_tests[i].name);
+            pass_count++;
+        };
+    }
+    
+    printf("\n\n=====================\n");
+    printf("%d/%d tests passed\n", pass_count, size);
+    return 0;
+}

content/aulas/12-tipos-de-dados/point2d.c

@@ -0,0 +1,33 @@
+#include <stdlib.h>
+#include "point2d.h"
+
+Point2D *point2D_new(double x, double y) {
+    return NULL;
+}
+
+
+void point2D_destroy(Point2D *p) {
+    
+}
+
+double point2D_get_x(Point2D *p) {
+    return 0;
+}
+
+double point2D_get_y(Point2D *p) {
+    return 0;
+}
+
+Point2D *point2D_add(Point2D *p1, Point2D *p2) {
+    return NULL;
+}
+
+double point2D_theta(Point2D *p1, Point2D *p2) {
+    return 0;
+}
+
+Point2D *point2D_scale(Point2D *p, double s) {
+    return NULL;
+}
+
+

content/aulas/12-tipos-de-dados/point2d.h

@@ -0,0 +1,19 @@
+#ifndef __POINT2D__
+#define __POINT2D__
+
+typedef struct{
+    double x, y;
+}Point2D;
+
+Point2D *point2D_new(double x, double y);
+void point2D_destroy(Point2D *p);
+
+double point2D_get_x(Point2D *p);
+double point2D_get_y(Point2D *p);
+
+Point2D *point2D_add(Point2D *p1, Point2D *p2);
+double point2D_theta(Point2D *p1, Point2D *p2);
+Point2D *point2D_scale(Point2D *p, double s);
+
+
+#endif

content/aulas/12-tipos-de-dados/slides.pdf

@@ -0,0 +1,14 @@
+// stack.h
+typedef struct {
+    int capacity; // capacidade máxima 
+    int size; // quantidade de elementos armazenados
+    int *data; // vetor para armazenar itens do TAD
+}stack_int;
+
+stack_int * stack_int_new(int capacity);
+void stack_int_delete(stack_int *_s);
+int stack_int_empty(stack_int *s);
+int stack_int_full(stack_int *s);
+void stack_int_push(stack_int *s, int value);
+int stack_int_pop(stack_int *s);
+

content/aulas/12-tipos-de-dados/stack.h

@@ -0,0 +1,81 @@
+#include "mintest/macros.h"
+#include "point2d.h"
+
+int test_new_destroy_get() {
+    Point2D *p = point2D_new(0, 0);
+
+    test_assert(point2D_get_x(p) == 0, "Erro na inicialização da componente x!");
+    test_assert(point2D_get_y(p) == 0, "Erro na inicialização da componente y!");
+
+    point2D_destroy(p);
+
+    Point2D *p2 = point2D_new(10, 20);
+
+    test_assert(point2D_get_x(p2) == 10, "Erro na inicialização da componente x!");
+    test_assert(point2D_get_y(p2) == 20, "Erro na inicialização da componente y!");
+
+    point2D_destroy(p2);
+
+    return 0;
+}
+
+int test_add() {
+    Point2D *a, *b, *c;
+    a = point2D_new(10.5, 20);
+    b = point2D_new(30, 40.3);
+    c = point2D_add(a, b);
+
+    test_assert(point2D_get_x(c) == 40.5, "Erro na soma: componente x!");
+    test_assert(point2D_get_y(c) == 60.3, "Erro na soma: componente x!");
+
+    point2D_destroy(a);
+    point2D_destroy(b);
+    point2D_destroy(c);
+
+    return 0;
+}
+
+int test_scale() {
+    Point2D *a, *b, *c;
+    a = point2D_new(10.5, 20);
+    b = point2D_scale(a, 2.5);
+
+    test_assert(point2D_get_x(b) == 26.25, "Erro na escala: componente x!");
+    test_assert(point2D_get_y(b) == 50, "Erro na escala: componente y!");
+
+    c = point2D_scale(a, 0);
+
+    test_assert(point2D_get_x(c) == 0, "Erro na escala: componente x!");
+    test_assert(point2D_get_y(c) == 0, "Erro na escala: componente y!");
+
+    point2D_destroy(a);
+    point2D_destroy(b);
+    point2D_destroy(c);
+
+    return 0;
+}
+
+int test_theta() {
+    Point2D *a, *b;
+    a = point2D_new(20, 30);
+    b = point2D_new(40, 50);
+
+    test_assert(point2D_theta(a, b) == 1, "Erro na inclinação da reta!");
+
+    point2D_destroy(a);
+    point2D_destroy(b);
+
+    a = point2D_new(20, 30);
+    b = point2D_new(40, 40);
+
+    test_assert(point2D_theta(a, b) == 0.5, "Erro na inclinação da reta!");
+
+    point2D_destroy(a);
+    point2D_destroy(b);
+
+    return 0;
+}
+
+test_list = { TEST(test_new_destroy_get), TEST(test_add), TEST(test_scale), TEST(test_theta) };
+
+#include "mintest/runner.h"

content/aulas/12-tipos-de-dados/stack.o

@@ -0,0 +1,20 @@
+// test_stack.c
+// gcc -Og -Wall -g test_stack.c stack.o -o teste_stack
+#include <stdio.h>
+#include "stack.h"
+
+int main() {
+    // Cria um stack com capacidade para 5 elementos
+    stack_int *s = stack_int_new(5);  
+
+    stack_int_push(s, 10);
+    stack_int_push(s, 20);
+    stack_int_push(s, 30);
+    // Remove o topo: 30
+    printf("Valor removido: %d\n", stack_int_pop(s)); 
+    // Remove o topo: 20
+    printf("Valor removido: %d\n", stack_int_pop(s));
+    stack_int_delete(s);  // Libera a memória
+
+    return 0;
+}