从Eclipse中的不兼容指针类型分配

Question

我已经看到很多关于这个主题的问题，但是从它们中解释不了多少，并且无法将它与我的代码进行比较。我不确定我做错了什么，但它似乎是对Eclipse的警告，我认为可能是因为它使我的功能表现得与应有的不同。

评论和变量是葡萄牙语，所以如果你需要我翻译它的任何部分，或者告诉你每个函数应该做什么，那就告诉我。

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

typedef struct _relemento
{
    /** string armazenada */
    char *nome;
    int x, y, id;
    struct _elemento *proximo;
} robot_lista;

typedef struct
{
    robot_lista *raiz;
    int tamanho;
} listarobots;

typedef struct _elemento
{
    /** string armazenada */
    int x;
    int y;
    int v;
    struct _elemento *proximo;
} elemento_lista;

typedef struct
{
    elemento_lista *raiz;
    int tamanho;
} lista;


listarobots* listarobots_nova()
{
    /* cria lista */
    listarobots *lst = (listarobots*) malloc(sizeof(listarobots));
    if(lst == NULL)
        return NULL;

    /* lista esta' vazia */
    lst->raiz = NULL;
    lst->tamanho = 0;

    return lst;
}

robot_lista* novorobot_str(const char* valor, int x, int y, int id)
{
    /* aloca memoria para a estrutura lista */
    robot_lista *item = (robot_lista *) malloc(sizeof(robot_lista));
    if(item == NULL)
        return NULL;

    /* aloca memoria para string */
    item->nome = (char *) malloc((strlen(valor)+1)*sizeof(char));
    if(item->nome == NULL)
    {
        free(item);
        return NULL;
    }

    /* copia valor */
    strcpy(item->nome, valor);
    item->x=x;
    item->y=y;
    item->id=id;
    /* item ainda nao tem proximo */
    item->proximo = NULL;

    return item;
}

int listarobots_insere(listarobots *lst, const char* valor, int x, int y,int id)
{

    robot_lista *curr = NULL, *temp;

    if (lst == NULL)
        return -1;

    temp = lst->raiz;

    /* cria novo item */
    curr = novorobot_str(valor, x, y, id);

    if (curr == NULL)
        return -1;

    lst->tamanho++;


    curr->proximo = temp;
    lst->raiz = curr;
    return 1;

}

int listarobot_pesquisa(listarobots *lst, const char* str, int* x, int* y, int *id)
{
    int i=0;
    robot_lista *aux;

    if(lst == NULL)
        return -1;

    /* pesquisa sequencial */
    for (aux = lst->raiz; aux != NULL; aux = aux->proximo, i++)
    {
        if (strcmp((aux->nome), str) == 0)
        {
            *x= aux->x;
            *y= aux->y;
            *id= aux->id;
            return i;
        }
    }
    return -1;
}

int listarobot_atribui(listarobots *lst, int pos, int x, int y)
{
    int i=0;
    robot_lista *aux;

    if (lst == NULL || pos < 0)
        return -1;

    aux = lst->raiz;

    /* procura item na posicao pos */
    for (i = 0; i < pos && aux != NULL; i++)
        aux = aux->proximo;

    /* se aux e' NULL entao nao existe posicao pos */
    if (aux == NULL)
        return -1;
    aux->x=x;
    aux->y=y;
    return pos;
}




lista* lista_nova()
{
    /* cria lista */
    lista *lst = (lista*) malloc(sizeof(lista));
    if(lst == NULL)
        return NULL;

    /* lista esta' vazia */
    lst->raiz = NULL;
    lst->tamanho = 0;

    return lst;
}
elemento_lista* novo_str(int x, int y, int v)
{
    /* aloca memoria para a estrutura lista */
    elemento_lista *item = (elemento_lista *) malloc(sizeof(elemento_lista));
    if(item == NULL)
        return NULL;

    item->v=v;
    item->x=x;
    item->y=y;

    /* item ainda nao tem proximo */
    item->proximo = NULL;

    return item;
}

int lista_insere(lista *lst, int x, int y, int v)
{
    elemento_lista *curr = NULL, *temp;

    if (lst == NULL)
        return -1;

    temp = lst->raiz;

    /* cria novo item */
    curr = novo_str(x,y,v);

    if (curr == NULL)
        return -1;

    lst->tamanho++;

    curr->proximo = temp;
    lst->raiz = curr;
    return v;

}

int lista_pesquisa(lista *lst, int x, int y)
{
    int i=0;
    elemento_lista *aux;

    if(lst == NULL)
        return -1;

    /* pesquisa sequencial */
    for (aux = lst->raiz; aux != NULL; aux = aux->proximo, i++)
    {
        if ((aux->x==x) && (aux->y==y))
        {
            return aux->v;
        }
    }
    return -1;
}

int lista_xy (lista *lst, int v, int *x , int* y)
{
    int i=0;
    elemento_lista *aux;

    if(lst == NULL)
        return -1;

    /* pesquisa sequencial */
    for (aux = lst->raiz; aux != NULL; aux = aux->proximo, i++)
    {
        if ((aux->v==v))
        {
            *x=aux->x;
            *y=aux->y;
            return 1;
        }
    }
    return -1;
}













void leitura(int *tamx,int *tamy,int *xminfinal, int* yminfinal, int *wx, int *wy, int *fimx, int *fimy, FILE * fp, grafo *robots, lista *celulas, listarobots *posicoes)
{
    int naofaznada,tamanho=0, i, x, y, xmax, xmin, ymax, ymin, v=1,dest,poslst, origem,id=0;
    char nome[16], aux;
    xmax=xmin=ymax=ymin=0;
    celulas=lista_nova();
    lista_insere(celulas, 0,0,0);
    fp = fopen("input.txt", "r");
    robots = grafo_novo(tamanho,NAODIRECIONADO);
    posicoes=listarobots_nova();
    fscanf( fp, " %c", &aux);
    while (aux!=EOF)
    {
        for (i=0;aux!= ',';i++)
        {
            nome[i]=aux;
            nome[i+1]='\0';
            fscanf(fp, " %c", &aux);
        }
        fscanf(fp, " %c", &aux);
        poslst=listarobot_pesquisa(posicoes, nome, &x, &y, &naofaznada);
        if(poslst==-1)
        {
            if(aux=='D')
            {
                x=0;
                y=-1;

            }
            if(aux=='U')
            {
                x=0;
                y=1;
            }
            if(aux=='L')
            {
                x=-1;
                y=0;
            }
            if(aux=='R')
            {
                x=1;
                y=0;
            }
            listarobots_insere(posicoes, nome, x, y, id);
            id++;
            origem=0;
            if(x>xmax) xmax=x;
            if(x<xmin) xmin=x;
            if(y>ymax) ymax=y;
            if(y<ymin) ymin=y;
            if(lista_pesquisa(celulas, x, y)==-1)
            {
                lista_insere(celulas, x, y, v);
                dest=v;
                v++;


                grafo_adiciona(robots, 0, dest);
                if(lista_pesquisa(celulas, (x+1),y)!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, (x+1), y));
                if(lista_pesquisa(celulas, (x-1),y)!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, (x-1), y));
                if(lista_pesquisa(celulas, x,(y+1))!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, x, (y+1)));
                if(lista_pesquisa(celulas, x,(y-1))!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, x, (y-1)));
            }
        }
        else
        {
            origem=lista_pesquisa(celulas,x, y);
            if(aux=='D')
            {
                y=y-1;

            }
            if(aux=='U')
            {
                y=y+1;
            }
            if(aux=='L')
            {
                x=x-1;
            }
            if(aux=='R')
            {
                x=x+1;
            }
            listarobot_atribui(posicoes, poslst, x, y);


        }
        if(x>xmax) xmax=x;
        if(x<xmin) xmin=x;
        if(y>ymax) ymax=y;
        if(y<ymin) ymin=y;
        if(lista_pesquisa(celulas, x, y)==-1)
        {
            lista_insere(celulas, x, y, v);
            dest=v;
            v++;


            grafo_adiciona(robots, origem, dest);
            if(lista_pesquisa(celulas, (x+1),y)!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, (x+1), y));
            if(lista_pesquisa(celulas, (x-1),y)!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, (x-1), y));
            if(lista_pesquisa(celulas, x,(y+1))!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, x, (y+1)));
            if(lista_pesquisa(celulas, x,(y-1))!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, x, (y-1)));
        }
        if(fscanf(fp, " %c", &aux)==EOF) break;
        if(aux=='?')
        {
            *wx=x;
            *wy=y;
            if(fscanf(fp, " %c", &aux)==EOF) break;
        }
        if(aux=='!')
        {
            *fimx=x;
            *fimy=y;
            if(fscanf(fp, " %c", &aux)==EOF) break;
        }

    }
    *tamx= xmax-xmin+1;
    *tamy= ymax-ymin +1;
    *xminfinal=xmin;
    *yminfinal=ymin;
    return ;
}

void mapeamento(FILE * out, int x, int y, int ymin, int xmin, int wx, int wy, int fimx, int fimy, lista* celulas )
{
    int xatual, yatual;
    for(yatual=ymin+ y-1; yatual!=ymin-1;yatual--)
    {
        for(xatual=xmin; xatual!=xmin+x; xatual++)
        {
            if((xatual==0) && (yatual==0)) fprintf(out," e ");
            else if((xatual==wx)&&(yatual==wy)) fprintf(out, " w ");
            else if((xatual==fimx)&&(yatual==fimy)) fprintf(out, " s ");
            else if(lista_pesquisa(celulas, x, y)==-1) fprintf(out, " * ");
            else if(lista_pesquisa(celulas, x, y)!=-1)fprintf(out, " . ");
            if(xatual==fimx) fprintf(out, "\n");
        }

    }
    return;
}

void caminhos(int wx, int wy, int fimx, int fimy, lista* celulas, FILE *fp, FILE *out, grafo *robots, listarobots* posicoes)
{
    int restantes,nfnx,nfny,i,id,is,antx,anty,novox,novoy,tamanhocaminho1,tamanhocaminho2, *caminho1, *caminho2, *posrobots;
    char *caminho,nome[16], aux;
    caminho1=grafo_bfs(robots, 0, lista_pesquisa(celulas, wx, wy), &tamanhocaminho1);
    caminho2=grafo_bfs(robots, lista_pesquisa(celulas, wx, wy), lista_pesquisa(celulas, fimx, fimy), &tamanhocaminho2);
    caminho= malloc((tamanhocaminho1+tamanhocaminho2)*sizeof(char));
    antx=0;
    anty=0;
    is=0;
    for(i=1; i<tamanhocaminho1; i++, is++)
    {
        lista_xy(celulas, caminho1[i], &novox, &novoy);
        if((novox-antx)==1) caminho[is]= 'R';
        else if((novox-antx)==-1) caminho[is]= 'L';
        else if((novoy-anty)==-1) caminho[is]= 'D';
        else if((novoy-anty)==1) caminho[is]= 'U';
        antx=novox;
        anty=novoy;
    }
    for(i=1; i<tamanhocaminho2; i++, is++)
    {
        lista_xy(celulas, caminho1[i], &novox, &novoy);
        if((novox-antx)==1) caminho[is]= 'R';
        else if((novox-antx)==-1) caminho[is]= 'L';
        else if((novoy-anty)==-1) caminho[is]= 'D';
        else if((novoy-anty)==1) caminho[is]= 'U';
        antx=novox;
        anty=novoy;
    }
    caminho[is]='\0';
    fprintf(out, "\n\n%s\n", caminho);
    free(caminho1);
    free(caminho2);
    fclose(fp);
    fp=fopen("input.txt", "r");
    restantes=posicoes->tamanho;
    posrobots=calloc (posicoes->tamanho, sizeof(int));
    fscanf(fp, " %c", &aux);
    while (aux!=EOF)
    {
        for (i=0;aux!= ',';i++)
        {
            nome[i]=aux;
            nome[i+1]='\0';
            fscanf(fp, " %c", &aux);
        }
        fscanf(fp, " %c", &aux);
        listarobot_pesquisa(posicoes, nome, &nfnx, &nfny, &id);
        if(posrobots[id]==-1) nfnx=1;
        else if(caminho[posrobots[id]]==aux) posrobots[id]++;
        else
        {
            posrobots[id]=-1;
            restantes--;
        }
        if(posrobots[id]==is) fprintf(out, "%s\n", nome);
        fscanf(fp, " %c", &aux);
        if(aux=='?')
        {
            fscanf(fp, " %c", &aux);
        }
        if(aux=='!')
        {
            fscanf(fp, " %c", &aux);
        }
    }
    if(restantes==0) fprintf(out, "0\n");

}

void output()
{

}

int main()
{
    FILE *fp, *out;
    grafo *robots;
    lista *celulas;
    listarobots *posicoes;
    celulas=(lista * )malloc(sizeof(lista));
    robots=(grafo * )malloc(sizeof(grafo));
    posicoes=(listarobots * )malloc(sizeof(listarobots));
    fp=(FILE * )malloc(sizeof(FILE));
    out=(FILE * )malloc(sizeof(FILE));
    int x,y,xmin, ymin,wx,wy,fimx,fimy;
    out=fopen("output.txt", "w");
    leitura(&x, &y, &xmin, &ymin,&wx, &wy, &fimx, &fimy, fp, robots, celulas, posicoes);
    fprintf(out,"largura:%d, altura:%d\n", x, y );
    mapeamento(out, x, y, ymin, xmin, wx, wy, fimx, fimy, celulas);
    //caminhos(wx, wy,fimx, fimy,celulas, fp, out, robots, posicoes);
    return 0;
}

额外的包括没有区别，我已经检查过，错误在这个代码块上，但为了以防万一，我将在这里发布include＆＃34; grafo的代码。 H＆＃34;

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

/* cria no da lista de adjacencias */
lista_no* cria_no(int v)
{
    lista_no* novo = (lista_no*)malloc(sizeof(lista_no));
    if(!novo)
        return NULL;

    novo->vertice = v;
    novo->proximo = NULL;

    return novo;
}

/* cria grafo com n vertices */
grafo* grafo_novo(int n, tipo_grafo tipo)
{
    grafo* g = (grafo*)malloc(sizeof(grafo));
    lista_no novo;
    if(g == NULL)
        return NULL;

    g->tamanho = 1;
    g->tipo = tipo;

    /* cria array de listas de adjacencias */
    g->adjacencias = (lista_adj*)calloc(n, sizeof(lista_adj));
    if(g->adjacencias == NULL)
    {
        free(g);
        return NULL;
    }
    g->adjacencias[0].inicio=NULL;


    return g;
}

/* apaga grafo e liberta memoria */
void grafo_apaga(grafo* g)
{
    if(g == NULL)
        return;

    if(g->adjacencias != NULL)
    {
        int v;
        for (v = 0; v < g->tamanho; v++)
        {
            while (g->adjacencias[v].inicio)
            {
                lista_no* aux = g->adjacencias[v].inicio;
                g->adjacencias[v].inicio = g->adjacencias[v].inicio->proximo;
                free(aux);
            }
        }
        free(g->adjacencias);
    }
    free(g);
}

/* adiciona uma aresta ao grafo*/
void grafo_adiciona(grafo *g, int origem, int dest)
{
    lista_no* novo,*aux,*ant;

    if (g == NULL || grafo_existe(g, origem, dest))
        return;

    /* adiciona uma aresta de origem para dest na lista de adjacencias */
    novo = cria_no(dest);
    novo->proximo = NULL;
    g->adjacencias = (lista_adj*)realloc(g->adjacencias, (g->tamanho+1)*sizeof(lista_adj));
    g->adjacencias[dest].inicio=NULL;
    g->tamanho++;
    ant= aux =g->adjacencias[origem].inicio;
    if(ant==NULL) g->adjacencias[origem].inicio=novo;
    else
    {
        aux=ant->proximo;

        while(aux!=NULL)
        {
            ant=aux;
            aux=ant->proximo;
        }
        ant->proximo=novo;
    }
    g->adjacencias[origem].tamanho++;

    if(g->tipo == NAODIRECIONADO)
    {
        /* adiciona tambem aresta de dest para origem */
        novo = cria_no(origem);
        novo->proximo = NULL;
        ant= aux =g->adjacencias[dest].inicio;
        if(ant==NULL) g->adjacencias[dest].inicio=novo;
        else
        {
            aux=ant->proximo;
            while(aux!=NULL)
            {
                ant=aux;
                aux=ant->proximo;
            }
            ant->proximo=novo;
        }
        g->adjacencias[dest].tamanho++;
    }
}

/* remove uma aresta do grafo*/
void grafo_remove(grafo *g, int origem, int dest)
{
    lista_no *aux, *prev;

    if (g == NULL || g->adjacencias[origem].inicio == NULL)
        return;

    aux = g->adjacencias[origem].inicio;
    /* caso especial: primeiro no' da lista */
    if(aux->vertice == dest)
    {
        g->adjacencias[origem].inicio = aux->proximo;
        free(aux);
    }
    else
    {
        prev = aux;
        aux = aux->proximo;
        while(aux != NULL)
        {
            if(aux->vertice == dest)
            {
                prev->proximo = aux->proximo;
                free(aux);
                break;
            }
            prev = aux;
            aux = aux->proximo;
        }
    }

    if(g->tipo == NAODIRECIONADO)
    {
        /* remove tambem aresta de dest para origem */
        /* caso especial: primeiro no' da lista */
        aux = g->adjacencias[dest].inicio;
        if(aux->vertice == origem)
        {
            g->adjacencias[dest].inicio = aux->proximo;
            free(aux);
        }
        else
        {
            prev = aux;
            aux = aux->proximo;
            while(aux != NULL)
            {
                if(aux->vertice == origem)
                {
                    prev->proximo = aux->proximo;
                    free(aux);
                    break;
                }
                prev = aux;
                aux = aux->proximo;
            }
        }
    }

}

/* verifica se existe uma aresta entre os vertices origem e dest */
int grafo_existe(grafo *g, int origem, int dest)
{
    if (g == NULL)
        return 0;

    lista_no* aux = g->adjacencias[origem].inicio;
    while (aux)
    {
        if(aux->vertice == dest)
            return 1;
        aux = aux->proximo;
    }
    return 0;
}

/* imprime as listas de adjacencias do grafo */
void grafo_imprime(grafo* g)
{
    int i;
    for (i = 0; i < g->tamanho; i++)
    {
        lista_no* aux = g->adjacencias[i].inicio;
        printf("%d: ", i);
        if(aux)
        {
            printf("%d", aux->vertice);
            aux = aux->proximo;

            while (aux)
            {
                printf("->%d", aux->vertice);
                aux = aux->proximo;
            }
        }
        printf("\n");
    }
}

int dfs_helper(grafo *g, int inicio, int fim, int profundidade, int *visitados)
{
    int i, d;

    if(visitados[inicio])
        return 0;

    visitados[inicio] = profundidade;

    if(inicio == fim)
        return profundidade;

    for(i=0; i < g->tamanho; i++)
    {
        if(grafo_existe(g, inicio, i))
        {
            d = dfs_helper(g, i, fim, profundidade + 1, visitados);
            if(d)
                return d;
        }
    }
    visitados[inicio] = 0;
    return 0;
}

/* retorna caminho entre origem e dest usando depth-first search (DFS)
   n guarda o tamanho do caminho
   nao garante caminho mais curto */
int* grafo_dfs(grafo *g, int inicio, int fim, int *n)
{
    int *visitados, *caminho;
    int profundidade, i, ret_i;

    if(g==NULL)
        return 0;

    visitados = calloc(g->tamanho, sizeof(int));
    profundidade = dfs_helper(g, inicio, fim, 1, visitados);

    if(profundidade == 0)
    {
        free(visitados);
        *n=0;
        return NULL;
    }

    /* reconstrucao do caminho */
    caminho = calloc(profundidade, sizeof(int));
    for (ret_i = 0; ret_i < profundidade; ret_i++)
        for (i = 0; i< g->tamanho; i++)
            if(visitados[i] == ret_i + 1)
            {
                caminho[ret_i] = i;
                break;
            }
    *n = profundidade;
    free(visitados);
    return caminho;
}


/* retorna caminho entre origem e dest usando breadth-first search (BFS)
   n guarda o tamanho do caminho
   garante caminho mais curto */
int* grafo_bfs(grafo *g, int inicio, int fim, int *n)
{
    int *caminho, *visitados, *fila;
    int profundidade, i, j, fila_inicio = 0, fila_fim=0;

    if(g==NULL)
        return 0;

    visitados = calloc(g->tamanho, sizeof(int));
    fila = calloc(g->tamanho, sizeof(int));

    for(i = 0; i < g->tamanho; i++)
        visitados[i] = -1;

    visitados[inicio] = inicio;
    fila[fila_fim++] = inicio;

    while(fila_inicio != fila_fim)
    {
        i = fila[fila_inicio];
        fila_inicio = (fila_inicio + 1) % g->tamanho;
        for(j = 0; j < g->tamanho; j++)
            if(grafo_existe(g, i, j) && visitados[j] == -1)
            {
                visitados[j] = i;
                fila[fila_fim] = j;
                fila_fim = (fila_fim + 1) % g->tamanho;
            }
    }

    /* reconstrucao do caminho */
    profundidade = 0;
    if(visitados[fim] >= 0)
    {
        int tmp = fim;
        profundidade = 1;
        while(visitados[tmp] != tmp)
        {
            profundidade++;
            tmp = visitados[tmp];
        }

        caminho = malloc(profundidade  * sizeof(int));
        tmp = fim;
        i = 0;
        while(i++ < profundidade)
        {
            caminho[profundidade - i] = tmp;
            tmp = visitados[tmp];
        }
    }

    free(fila);
    free(visitados);

    *n=profundidade;
    return caminho;
}

警告是：

Description Resource    Path    Location    Type
assignment from incompatible pointer type [enabled by default]  trabalho.c  /trabalho/src   line 110    C/C++ Problem
assignment from incompatible pointer type [enabled by default]  trabalho.c  /trabalho/src   line 135    C/C++ Problem
assignment from incompatible pointer type [enabled by default]  trabalho.c  /trabalho/src   line 95 C/C++ Problem

我感谢您提供的任何和所有帮助。我在编程方面还很陌生，这个警告完全搞砸了我的想法。

Answer 1

看起来您正在将proximo（指向_elemento）分配给指向robot_lista的变量。