Início / coding / Perguntas / 79438982
Accepted
devolskii
Asked: 2025-02-14 17:58:54 +0800 CST

Problema com tipo de ponteiro incompatível

  • 772

Eu tenho este código:

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

typedef struct{
    int data;
    struct node *next;
} NODE;

NODE *head = NULL;

void display_ll(NODE *head){
    if (head == NULL){
        printf("\nList is empty");
    } else{
        for(NODE *curr=head; curr!=NULL; curr=curr->next){
            printf("%d ->", curr->data);
        }
        printf("\b\b  ");
    }
}

int main(void){
    NODE *temp = (NODE *)malloc(sizeof(NODE));
    temp->data = 5;
    temp->next = NULL;
    head = temp;
    display_ll(head);
    return 0;
}

Na linha 15, onde faço curr=curr->nexto forloop, estou recebendo um aviso se compilado usando clang, e um erro se compilado usando gcc:

  1. barulho: 
    warning: incompatible pointer types assigning to 'NODE *' from 'struct node *' [-Wincompatible-pointer-types]
  2. gcc: 
    error: assignment to ‘NODE *’ from incompatible pointer type ‘struct node *’ [-Wincompatible-pointer-types]`

Eu imaginei uma solução alternativa onde escrevemos a estrutura como typedef struct node {...} NODE;e funciona. Mas eu quero saber se há alguma correção para isso sem essa redefinição de struct.

c

4 respostas

  1. Best Answer

    O nome da sua struct não é node.
    Na verdade, ele não tem nome ( struct{ ... }), e NODEé um alias para aquela struct sem nome.

    Portanto nesta linha:

    struct node *next;

    nextnão é um ponteiro para a estrutura atual como você parece esperar (é um ponteiro para alguma outra suposição struct nodeque é declarada aqui).

    Para consertar isso, basta dar o nome à sua estrutura:

    //-------------vvvv
typedef struct node {
    int data;
    struct node *next; 
} NODE;

    Isso criará nextum ponteiro para a estrutura atual, conforme você espera.

    Live demo

    Uma observação lateral:
    Você deve sempre habilitar e anotar os avisos do compilador. No display_llparâmetro headestá escondendo o global. Mesmo que seja isso que você queria que acontecesse, é recomendado mudar o nome do parâmetro para evitar confusão.

    • 2

  2. Mas o NODE não vai fazer isso sozinho? Por que preciso de struct node

        struct node *next;

    struct nodee NODEsão algo diferentes. nodeé uma tag e NODEé um alias .

    Você precisa adicionar a tag à sua declaração de struct:

    typedef struct node{
    • 1

  3. Você não tem um struct node, você tem uma struct sem nome.

    • 0

  4. Estruturas em C são bem confusas, pois podem ser usadas de muitas maneiras diferentes.

    Para definir uma estrutura em C você escreveria

    struct node {
    int data;
};

    Onde nodeestá uma tag struct , um tipo especial de identificador que vive em um namespace diferente de variáveis ​​comuns. Para declarar uma variável com base nessa tag struct, temos que digitar struct node x;com a structpalavra-chave presente.

    Se escrevermos

    struct {
    int data;
};

    então essa é uma struct anônima sem uma tag struct. Essa definição de struct só é visível aqui - não podemos declarar variáveis ​​dessa mesma struct anônima em outro lugar. O que significa que é inútil - a menos que adicionemos um nome de variável no final:

    struct {
    int data;
} name;

    Agora poderíamos definir uma struct anônima e ao mesmo tempo criar um alias para ela com um typedef, para tornar possível declarar variáveis ​​dessa struct em qualquer lugar:

    typedef struct {
   int data;
} node_t;

    Aqui node_tnão está o nome da variável, mas o nome de um tipo. O acima é talvez a maneira mais comum de definir structs em C.

    Se usarmos esse estilo, teremos problemas quando fizermos uma struct de autorreferência. Porque não importa qual estilo usemos, a definição da struct não estará completa até chegarmos ao };no final. O que significa que não podemos nos referir a ela de dentro da definição da struct - porque a definição ainda não está completa.

    Para resolver isso, podemos declarar a estrutura:

    struct node;

    Este é um tipo incompleto do qual ainda não podemos criar nenhuma instância - não até chegarmos à };definição struct node { ... };mais tarde, onde a definição do tipo é concluída.

    No entanto, podemos criar um ponteiro para um tipo incompleto - mesmo que ainda não possamos declarar um objeto dele:

    void func (struct node* ptr){} // OK
void func (struct node obj){}  // not OK, incomplete type

    E seria por isso que às vezes obtemos erros estranhos do compilador reclamando sobre "o tipo está incompleto" quando esquecemos de incluir algum cabeçalho que torna a definição de struct visível. Uma vez que o compilador vê a definição de struct dentro da mesma unidade de tradução, somos capazes de declarar objetos desse tipo e acessar os membros.

    Usando o mesmo truque acima, podemos definir uma struct como:

    struct node {
   int data;
   struct node *next;
};

    Aqui struct node *nextestá um ponteiro para um tipo incompleto, prestes a ser concluído na próxima linha.

    No entanto, se escrevermos

    typedef struct {
    int data;
    struct node *next;
} node_t;

    Então o compilador declara um ponteiro para um tipo incompleto struct node, mas esse não é o struct que estamos definindo agora. Esse struct é anônimo sem uma tag struct e, além disso, nomeamos o tipo node_t- nenhum deles tem uma conexão com struct node. Então o compilador pensa struct nodeque é algo definido em outro lugar.

    Portanto, struct node*não é compatível, node_t*pois, até onde o compilador pode perceber, são duas estruturas diferentes.

    Como antes, podemos resolver isso fornecendo uma tag struct:

    typedef struct node {
    int data;
    struct node *next;
} node_t;

    Agora struct node* nexté um ponteiro para o tipo incompleto struct nodee também temos um alias para esse tipo chamado node_t. O que significa que uma vez que a definição e typedef estão no lugar, podemos usar struct nodee node_tde forma intercambiável.

    Além disso, se desejarmos, podemos dar typedefo mesmo nome à tag struct e à tag struct, já que elas estão em espaços de nomes diferentes:

    typedef struct node {
    int data;
    struct node *next;
} node;

    Leitura adicional:

    O tipo incompleto é muito útil para implementar encapsulamento privado:
    Como fazer encapsulamento privado em C?

    Há uma pequena guerra de estilos acontecendo sobre qual estilo de struct usar. No entanto, nem tudo é subjetivo:
    há razões técnicas para escolher um estilo de codificação de struct em vez do outro?

    • 0

relate perguntas