当将void指针类型转换为结构指针时，“使用未声明的标识符”

Question

I am new to C and as a (classic) exercise I am trying to implement some operations on linked lists. I haven't gotten very far yet, though... When I am trying to declare and initialize the root node as follows:

#include <stdlib.h>

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

int main() {
    struct intNode_t* root = ( intNode_t* ) malloc( sizeof( struct intNode_t ) );
    return 0;
}

the compiler (clang) is giving me the error "use of undeclared identifier" at the place where I am trying to typecast the void pointer returned by malloc to a pointer to intNode_t. I realise this is a noob question, but I couldn't find the answer elsewhere. Any suggestions?

Answer 1

The names of structs in C occupy a separate namespace from the space of names of fundamental types and typedefs (see this question for details). Therefore, the name of your struct type is struct intNode_t ; there is no type called intNode_t .

You can either always spell out the name as struct intNode_t , or you can create a type alias for it. There are many different patterns of this in real code:

Separate tag name, separate declaration:

typedef struct foo_t_ foo_t;

struct foo_t_ { /* ... */ };

This allows you to put the type alias in a header and publish it as an opaque API type without ever revealing the actual type definition.

Separate tag name, typedef in struct definition:

typedef struct foo_t_ { /* ... */ } foo_t;

Reuse name:

typedef struct foo_t { /* ... */ } foo_t;

This style allows users to be careless about spelling foo_t or struct foo_t .

Don't name the struct:

typedef struct { /* ... */ } foo_t;

---

However, in your code you don't actually need to repeat the name, since you should not cast the result of malloc and instead rely on the built-in implicit conversion from void pointer to object pointer. You also shouldn't repeat the type that's already known, and use the expression form of sizeof instead. So you want:

int main()
{
    struct intNode_t* root = malloc(sizeof *root);
}

(Also note that return 0 is implied from main .)

Answer 2

No need to repeat yourself. If you don't repeat yourself you can make fewer errors.

struct intNode_t *root;
root = malloc( sizeof *root );

• the cast is not needed; malloc() returns a void* , which is exchangeable with every (non-function) pointer type.
• there are two syntax variants for sizeof: sizeof(type) and sizeof expression The first one needs () , the second one does not. Most people prefer the second form, because the expression (in your case *root ) always will yield the correct type, and thus: size.

And, the definition + assignment above can be combined into a definition + initialiser, all fitting on one line:

struct intNode_t *root = malloc( sizeof *root );

Answer 3

Name intNode_t was not declared in the program. There is declared structure tag name intNode_t .

So you need to write

struct intNode_t* root = ( struct intNode_t* ) malloc( sizeof( struct intNode_t ) );

Or you could introduce identifier name intNode_t the following way

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

In this case you may write

struct intNode_t* root = ( intNode_t* ) malloc( sizeof( struct intNode_t ) );