ajuda para solucionar conflicting type error

[caramassada]

Fala galera, po to fazendo um trabalhinho pra o meu amigo q faz biologia. Ele vai entrar com uma fila de inteiros a qual ele tem q comparar com outras filas , se as outras filas contiverem um numero igual a fila a se comparar, esse numero será excluido.

Em outras palavras, é uma subtração de conjuntos, eu tenho q subtrair um conjunto fila de inteiros de outros conjuntos fila de inteiros. O erro q dá, é no struct fila q eu ja tinha até testado, nao sei o porque do erro, mas deve ser uma coisa muito boba.

 

erro: conflicting type error

 

 

 

 

MAIN:
 
#include <stdio.h>
#include <stdlib.h>
#include "fila.h"
#include "listaDeFilas.h"
 
int main()
{
    printf("teste\n");
    TF* novo = NULL;
    TLF* listaDasListas;
    novo = insere(novo, 5);
    novo = insere(novo, 3);
    novo = insere(novo, 4);
    novo = insere(novo, 3);
    novo = insere(novo, 3);
    imprime(novo);
    printf("\n");
    retiraElemts(novo , 3);
    imprime(novo);
    listaDasListas = insereList(listaDasListas , novo);
    imprimeLists(listaDasListas);
    libera(novo);
    return 0;
}
 
FILA.H:
 

#include <stdio.h>
#include <stdlib.h>
 
typedef struct fila{
  int info;
  struct fila *prox , *ant;
} TF;
 
TF* insere(TF *l, int elem);
void imprime(TF *l);
void libera(TF *l);
TF* retira(TF *l);
void retiraElemts(TF *l , int num);
TF* busca(TF *l, int elem);
 

 
 
FILA.C:
 

#include "fila.h"
 
TF* insere(TF *l, int elem){
    TF* novo = (TF*) malloc (sizeof(TF));
    novo->info = elem;
    novo->prox = NULL;
    if(!l){
        novo->ant = NULL;
        return novo;
    }
    TF* p = l;
    while(p->prox){
        p=p->prox;
    }
    novo->ant = p;
    p->prox=novo;
    return l;
}
 
void imprime(TF *l){
  TF *p = l;
  while(p){
    printf("% d ", p->info);
    p = p->prox;
  }
}
 
void libera(TF *l){
  TF *p = l, *q;
  while(p){
    q = p;
    p = p->prox;
    free(q);
  }
}
 
TF* retira(TF *l){
  TF *p = l;
  l=l->prox;
  free(p);
  return l;
}
void retiraElemts(TF *l , int num){    //retira todas as ocorrencias de um numero na lista *l.
 
    TF *p, *antes, *inutil;
    p = l;
    inutil = busca(p, num);
    while(inutil){
        antes = inutil->ant;
        p = retira(inutil);
        if(p){                       //verifica se p nao é NULL.
        p->ant = antes;
        }
        if(antes){                  //verifica se antes é um nó a se linkar, se for NULL nao precisa.
        antes->prox = p;
        }
        inutil = busca(p, num);
    }
}
TF* busca(TF *l, int elem){
  TF *p = l;
  while((p) && (p->info != elem)) p = p->prox;
  return p;
}
 

 
projetoBio.rar

[ScreenBlack]

No arquivo listaDeFilas.h, foi declarada uma struct com elementos do tipo fila, porém, no arquivo listaDeFilas.c, está sendo atribuído esse tipo fila em uma variável tipo listaDeFilas:
 

    while ( p->prox )    {        p = p->prox;    }

Troquei na struct listaDeFilas.h o tipo dos elementos para listaDeFilas, e o código compilou corretamente:

typedef struct listaDeFilas{    TF* unidade;    struct listaDeFilas *prox;    struct listaDeFilas *ant;} TLF;

Só não sei dizer se o resultado de saída é o que você pretende:

 5  3  4  3  3 5  4  5  4

[caramassada]

Bom dia, amigo @ScreenBlack, você sem dúvida achou o erro bobo.   O resultado de saída era o q eu pretendia mesmo, (a main tinha só um teste). Mas o q eu nao entendo , é q eu ja mudei o tipo para listaDeFilas, o código compilou, mas quando executo a main, ele para de funcionar. Acho q essa tipagem equivocado (q eu dei mole) trouxe erros em todo o listadeFilas.c. vou dar uma olhada aqui, mas muito obrigado amigo!   

amigo @ScreenBlack, outro erro bobo encontrado, eu estava declarando a variavel  "TLF* listaDasListas" na main, sem inicializar ela com NULL    isso dava erro no insereList. Ali no if(!Lists)... ele nao passava no if nunca porque sempre tinha sujeira por eu nao inicializar a variavel como NULL. valeu amigo você me ajudou bastante!   

 

TLF* insereList(TLF *lLists, TF* uni){

 

    TLF* novo = (TLF*) malloc (sizeof(TLF));

    novo->unidade = uni;

    novo->prox = NULL;

   

    if(!lLists){

        novo->ant = NULL;

        return novo;

    }

    TLF* p = lLists;

    while(p->prox){

        p = p->prox;

    }

    novo->ant = p;

    p->prox=novo;

    return lLists;

}