Why does using Node(..Node{..), as below, while defining a struct type gives a compile time error.
typedef struct node Node;
Node{
int data;
Node *next;
};
There is a very basic concept that is confusing me, please advise or refer me to a relevant link.
Typedef is used to provide an alias to some another type. It is not a macro, it is not substituted for something at the place of use.
The correct definition might be:
typedef struct node {
int data;
struct node* next;
} Node;
At the very least, you need it to say
typedef struct node Node;
struct Node{
int data;
Node *next;
};
However, you can do this:
typedef struct {
int data;
struct Node *next;
}Node;
Now you can easily create instances of the struct Node you have created by:
Node node, *pNode;
Where node is the name of a new variable of type struct Node.
and *pNode is a pointer to the same, initialized by:
pNode = &node;
Related
typedef struct node{
int val;
node *next;
} node;
node *start;
Here this code throws an error on line 3. But if I modify it like this,
typedef struct node{
int val;
struct node *next;
} node;
node *start;
This is correct?
But why the compiler do so? And how the compiler execute it?
The problem is that the node type doesn't exist until after the end of the typedef declaration, so it cannot be referenced in the structure body. But the structure tag in struct node can.
My preferred solution is to declare the typedef using a forward reference to the structure definition, then define the structure in a second declaration. The advantage is that it allows the typedef name to be used inside the structure defintion. It looks like this:
typedef struct node node;
struct node {
int val;
node *next;
};
This allows you to use the typedef name node consistently in all declarations, including the ones inside the structure definition.
I am a bit comfused about the row of these declarations. I want to make a linked-list for my program but for some reason it keeps putting error when I try to compile it. Basically this will be my main node model and I also have another struct after it (WITHOUT TYPEDEF) for my list. Which compiles just fine. I don't know what's wrong.
I have already tried to put the typedef over the struct student.
typedef struct
{
char name[50];
int id;
node next;
}student;
typedef student* node;
typedef struct listR* list;
struct listR
{
node head,tail;
int size;
};
error:
unknown type name 'node'
warning:
initialization make pointer from integer without a cast
The compiler doesn't know what a node is, because you create the node type after creating the structure.
You can do either :
typedef struct node node;
struct node
{
char name[50];
int id;
node* next;
};
To tell the compiler what a node is,
Or
typedef struct node {
char name[50];
int id;
struct node* next;
} node;
I would use this:
struct Node
{
struct Node *next;
struct Node *prev;
};
But then I happen to be one of those who does not like typedeffing structs without a good reason. Read more here: https://stackoverflow.com/a/54752982/6699433
I have the following snippet of code:
typedef int T;
typedef struct Node *pNode;
typedef struct Node{
T item;
pNode next;
}Node;
The first and the last typedef statement are pretty clear to me, but I don't seem to understand the second.
Why is it defined as a structure when it's just a pointer to a Node? And why is it not referred to as a pointer in the pNode next; statement?
This:
typedef struct Node *pNode;
creates pNode as an alias for the type struct Node *, i.e. "pointer to struct Node".
I'm opposed to "hiding" pointers with typedef, but this is quite common.
I'd write it:
typedef struct Node {
int item;
struct Node *next;
} Node;
I am studying code examples from my professor in order to become better acquainted with linked data structures.
In our linked-list.c example the professor defines a type Node as follows:
typedef struct node {
int data;
struct node *next;
} Node;
What's the point of the lower case node? I was under the impression that you could just write, for example:
typedef struct {
int data;
struct node *next;
} Node;
and then use Node as its own type. Does it have something to do with the fact that if you don't include a lower case node then when the compiler is evaluating the code it will not be able to understand what is meant by "struct node *next"?
Take a look at this declaration:
struct node {
int data;
struct node *next;
};
typedef struct node Node;
This can be combined into a single statement (simplifying a declaration):
typedef struct node {
int data;
struct node *next;
} Node;
Does it have something to do with the fact that if you don't include a lower case node then when the compiler is evaluating the code it will not be able to understand what is meant by "struct node *next"?
Yes.
The node in struct node is the tag of the struct type. If you give the struct a tag, you can refer to that type from the moment on the tag is complete, so in
typedef struct node {
int data;
struct node *next;
} Node;
the struct node *next; declares a member next that is a pointer to the struct type being defined. The typedef name Node is not available before the ; ending the definition is reached.
If you omit the tag, you cannot refer to the type being defined in any way before the typedef is complete, so in
typedef struct {
int data;
struct node *next;
} Node;
the line struct node *next; declares a new, unrelated, incomplete struct type with the tag node that next points to.
That's valid, but nothing about struct node is known (unless it is defined somewhere else), so you can't use the next pointer without casting it to a pointer to a complete type everywhere (not quite everywhere, Node foo; foo.next = malloc(12); etc. would still work).
He is defining a temporary name for the node because he is using a well know technique to avoid writing struct node on the declaration of each struct object.
If he would just do:
struct node {
int data;
struct node *next;
};
you would have had to use:
struct node* node;
to declare a new node. And to avoid that you would have to define later:
typedef struct node Node;
in order to be able to declare objects like the following:
Node* node;
In the end:
typedef struct node {
int data;
struct node *next;
} Node;
Is just a shortcut for struct node { ... }; in addition to typedef struct node Node;.
Here struct node is a type like int
and Hence
struct node {
int data;
struct node *next;
}NodeVar;
means you are declaring a single variable Node of struct node.
like int intVar;
typedef is to make your code understandable.
so that when you use
typedef struct node Node;
you can use the same declaration as
Node NodeVar;
Consider this code:
#include <stdio.h>
typedef struct {
int data;
struct node *next;
} Node;
int main()
{
Node a, b = {10, NULL};
a.next = &b;
printf("%d\n", a.next->data);
}
This won't compile. The compiler has no idea what a struct node is, other than it exists. So you might change the definition in the struct to Node *next;. The typedef isn't in scope before it's declared, so it still won't compile. The simple answer is to do as he said, use the node tag after struct, and it works fine.
The lower case 'node' is a structure type... i.e. a struct node { stuff } is a node structure containing stuff.
On the other hand, the upper case "Node" is a completely new data type which refers to a 'struct node'
Generally (though in C++ I think you can), you cannot pass around a "node" in a C program... for example as an argument to a function. Rather, you would have to pass a 'struct node' as your argument...
// this will throw a syntax error because "node" is not a data type,
// it's a structure type.
void myFunc( node* arg );
// while this will not because we're telling the compiler we're
// passing a struct of node
void myFunc( struct node* arg );
// On the other hand, you *can* use the typedef shorthand to declare
// passing a pointer to a custom data type that has been defined
// as 'struct node'
void myFunc( Node* arg );
Have a question about typedef in C.
I have defined struct:
typedef struct Node {
int data;
struct Node *nextptr;
} nodes;
How would I create typedef pointers to struct Node ??
Thanks !
You can typedef them at the same time:
typedef struct Node {
int data;
struct Node *nextptr;
} node, *node_ptr;
This is arguably hard to understand, but it has a lot to do with why C's declaration syntax works the way it does (i.e. why int* foo, bar; declares bar to be an int rather than an int*
Or you can build on your existing typedef:
typedef struct Node {
int data;
struct Node *nextptr;
} node;
typedef node* node_ptr;
Or you can do it from scratch, the same way that you'd typedef anything else:
typedef struct Node* node_ptr;
To my taste, the easiest and clearest way is to do forward declarations of the struct and typedef to the struct and the pointer:
typedef struct node node;
typedef node * node_ptr;
struct node {
int data;
node_ptr nextptr;
};
Though I'd say that I don't like pointer typedef too much.
Using the same name as typedef and struct tag in the forward declaration make things clearer and eases the API compability with C++.
Also you should be clearer with the names of your types, of whether or not they represent one node or a set of nodes.
Like so:
typedef nodes * your_type;
Or:
typedef struct Node * your_type;
But I would prefer the first since you already defined a type for struct Node.