Cria arquivo para tipo No

Makefile

@@ -10,7 +10,7 @@ test: main
 	chmod +x runTests.sh; \
 	./runTests.sh
 
-main: main.c tabuleiro.o filha.o
+main: main.c tabuleiro.o filha.o no.o 
 	$(CC) $(CFLAGS) -o $@ $^
 
 clean:

filha.c

-#include "filha.h"
 #include <stdbool.h>
 #include <stdlib.h>
-
-struct No {
-    void *conteudo;
-    No anterior, proximo;
-};
+#include "filha.h"
+#include "no.h"
 
 struct Filha {
     unsigned int tamanho;
@@ -24,58 +20,46 @@ unsigned int tamanhoFilha(Filha f) {
     return f->tamanho;
 }
 
-No primeiroNo(Filha f) {
+No primeiroNoFilha(Filha f) {
     if(f->tamanho == 0) {
         return NULL;
     }
     No n = f->primeiro;
-    f->primeiro = f->primeiro->proximo;
-    n->anterior = NULL;
-    n->proximo = NULL;
+    f->primeiro = getSucessorNo(f->primeiro);
+    setSucessorNo(n, NULL);
+    setAntecessorNo(n, NULL);
     return n;
 }
 
-No ultimoNo(Filha f) {
+No ultimoNoFilha(Filha f) {
     if(f->tamanho == 0) {
         return NULL;
     }
     No n = f->ultimo;
-    f->ultimo = f->ultimo->anterior;
-    n->anterior = NULL;
-    n->proximo = NULL;
+    f->ultimo = getAntecessorNo(f->ultimo);
+    setSucessorNo(n, NULL);
+    setAntecessorNo(n, NULL);
     return n;
 }
 
-No sucessorNo(No n) {
-    return n->proximo;
-}
-
-No antecessorNo(No n) {
-    return n->anterior;
-}
-
-void *conteudo(No n) {
-    return n->conteudo;
-}
-
-No insere(void *conteudo, Filha f) {
-    No novo = malloc(sizeof(struct No));
+No insereFilha(void *conteudo, Filha f) {
+    No novo = criaNo();
 
     if(!novo) return NULL;
 
-    novo->conteudo = conteudo;
-    novo->anterior = f->ultimo;
+    setConteudo(novo, conteudo);
+    setAntecessorNo(novo, f->ultimo);
     ++f->tamanho;
     return f->ultimo = novo;
 }
 
-bool destroi(Filha f, bool destroi(void *)) {
+bool destroiFilha(Filha f, bool destroi(void *)) {
     No n;
     bool ok=true;
 
-    while( (n = primeiroNo(f)) ) {
+    while( (n = primeiroNoFilha(f)) ) {
         if(destroi)
-            ok &= destroi(conteudo(n));
+            ok &= destroi(getConteudo(n));
         free(n);
     }
     free(f);

filha.h

 #ifndef _FILHA_
 #define _FILHA_
 #include <stdbool.h>
+#include "no.h"
 
 // Filha é uma estrutura que pode ser vista como Fila ou Pilha
 typedef struct Filha *Filha;
@@ -16,24 +17,15 @@ Filha constroiFilha();
 unsigned int tamanhoFilha(Filha f);
 
 // Remove o primeiro nó da filha f ou retorna NULL se f for vazia
-No primeiroNo(Filha f);
+No primeiroNoFilha(Filha f);
 
 // Remove o último nó da filha f ou retorna NULL se f for vazia
-No ultimoNo(Filha f);
-
-// Devolve o nó sucessor de n ou NULL se n é o último nó da filha
-No sucessorNo(No n);
-
-// Devolve o nó antecessor de n ou NULL se n é o primeiro nó da filha
-No antecessorNo(No n);
-
-// Devolve o conteúdo de n
-void *conteudo(No n);
+No ultimoNoFilha(Filha f);
 
 // Insere um novo nó no fim da Filha f
 //
 // Devolve o nó recém criado ou NULL em caso de falha
-No insere(void *conteudo, Filha f);
+No insereFilha(void *conteudo, Filha f);
 
 // Desaloca a filha f e todos os seus nós
 //
@@ -42,7 +34,7 @@ No insere(void *conteudo, Filha f);
 // para cada nó n da filha
 //
 // devolve true em caso de sucesso ou false em caso de falha
-bool destroi(Filha f, bool destroi(void *));
+bool destroiFilha(Filha f, bool destroi(void *));
 
 // Impreme todos os nós da filha f
 //

main.c

@@ -3,27 +3,27 @@
 #include <stdio.h>
 #include <time.h>
 #include "tabuleiro.h"
-#include "jogador.h"
+// #include "jogador.h"
 
 int main() {
     Tblr t = criaTblr();
-    // Aloca o tabuleiro em um único array em vez de um "array de arrays"   
+    // Aloca o tabuleiro em um único array em vez de um "array de arrays"
     if(!leTblr(t)) {
         puts("Erro na leitura do tabuleiro");
         return -1;
     }
     imprimeTblr(t);
 
-    // declara o grafo ponderado e seu primeiro nodo 
-    grafo = criaGrafo(t);
-    if(grafo == NULL)) {
-        puts("Erro na criacao do grafo");
-        return -1;
-    }
-    // faz o jogador jogar o jogo a partir do tabuleiro dado
-    // o retorno do jogador sera um vetor contendo os numeros referentes a menor jogada encontrada por ele
-    int *jogadas;
-    jogadas = Joga(grafo, t);
+    // // declara o grafo ponderado e seu primeiro nodo
+    // grafo = criaGrafo(t);
+    // if(grafo == NULL)) {
+    //     puts("Erro na criacao do grafo");
+    //     return -1;
+    // }
+    // // faz o jogador jogar o jogo a partir do tabuleiro dado
+    // // o retorno do jogador sera um vetor contendo os numeros referentes a menor jogada encontrada por ele
+    // int *jogadas;
+    // jogadas = Joga(grafo, t);
 
     return 0;
 }

no.c

+#include <stdlib.h>
+#include "no.h"
+
+struct No {
+    void *conteudo;
+    No anterior, proximo;
+};
+
+No criaNo() {
+    No n = malloc(sizeof(struct No));
+
+    n->anterior = NULL;
+    n->proximo = NULL;
+    return n;
+}
+
+No getSucessorNo(No n) {
+    return n->proximo;
+}
+
+void setSucessorNo(No n, No p) {
+    n->proximo = p;
+}
+
+No getAntecessorNo(No n) {
+    return n->anterior;
+}
+
+void setAntecessorNo(No n, No p) {
+    n->anterior = p;
+}
+
+void *getConteudo(No n) {
+    return n->conteudo;
+}
+
+void setConteudo(No n, void *conteudo) {
+    n->conteudo = conteudo;
+}

no.h

+#ifndef _NO_
+#define _NO_
+
+// Nó cujo conteúdo é um void *
+typedef struct No *No;
+
+// Cria um nó vazio e devolve
+No criaNo();
+
+// Devolve o nó sucessor de n ou NULL se n é o último nó da filha
+No getSucessorNo(No n);
+
+// Define o nó sucessor de n
+void setSucessorNo(No n, No p);
+
+// Devolve o nó antecessor de n ou NULL se n é o primeiro nó da filha
+No getAntecessorNo(No n);
+
+// Define o nó antecessor de n
+void setAntecessorNo(No n, No p);
+
+// Devolve o conteúdo de n
+void *getConteudo(No n);
+
+void setConteudo(No n, void *conteudo);
+
+#endif