In C, is there any effective difference between declaring a struct as
typedef struct {...} Foo; and
struct Foo {...}; I know the second requires you to prefix uses with struct, but what are the differences between these two definitions that I'll notice when writing or executing the program? What about with enums?
Update: please see comments attached to answer for clarification.
Original post.
Besides having to write "struct" everywhere, something else of note is that using a typedef will allow you to avoid subtle syntax errors when working with pointers:
Quote:
Typedefs can also simplify declarations for pointer types. Consider this:
struct Node { int data; struct Node *nextptr; }; Using typedef, the above code can be rewritten like this:
typedef struct Node Node; struct Node { int data; Node *nextptr; }; In C, one can declare multiple variables of the same type in a single statement, even mixing pointer and non-pointers. However, one would need to prefix an asterisk to each variable to designate it as a pointer. In the following, a programmer might assume that errptr was indeed a Node *, but a typographical error means that errptr is a Node. This can lead to subtle syntax errors.
struct Node *startptr, *endptr, *curptr, *prevptr, errptr, *refptr; By defining a Node * typedef, it is assured that all the variables will be pointer types.
typedef struct Node *NodePtr; ... NodePtr startptr, endptr, curptr, prevptr, errptr, refptr; 
typedef for a pointer type, not for a structure type. Typedefs for pointer types are often considered to be poor style, the rationale being that pointers are so integral to C that hiding somethings "pointerness" can cause confusion. The multiple declaration problem can be avoided by declaring just one object per line (or by being very careful). And the error will probably be detected the first time you try to use errptr.
typedef'ing a pointer should only be done if the type is truly opaque.If you write
typedef struct {...} foo;
It saves you from having to write struct foo everywhere: you can just write foo.
(You get this notational convenience for free in C++ by the way).
I would look at this SO question and then summarize that there is no appreciable functional difference between struct { ... } and typedef struct { ... } although the latter may make your code less cumbersome and easier to understand if used correctly.
typedefsimply defines an alias for a certain type. If that type is a structure, an enumeration or something else doesn't matter.typedefwithout a typedef-name? Is this about the purpose oftypedefin general? Is this about nameless struct types? There's no way to say whether the OP's examples are built that way deliberately or by mistake. Please, clarify the question.