By Manoj Doubts


2008-10-31 07:14:03 8 Comments

I have seen many programs consisting of structures like the one below

typedef struct 
{
    int i;
    char k;
} elem;

elem user;

Why is it needed so often? Any specific reason or applicable area?

15 comments

@unwind 2008-10-31 07:37:05

As Greg Hewgill said, the typedef means you no longer have to write struct all over the place. That not only saves keystrokes, it also can make the code cleaner since it provides a smidgen more abstraction.

Stuff like

typedef struct {
  int x, y;
} Point;

Point point_new(int x, int y)
{
  Point a;
  a.x = x;
  a.y = y;
  return a;
}

becomes cleaner when you don't need to see the "struct" keyword all over the place, it looks more as if there really is a type called "Point" in your language. Which, after the typedef, is the case I guess.

Also note that while your example (and mine) omitted naming the struct itself, actually naming it is also useful for when you want to provide an opaque type. Then you'd have code like this in the header, for instance:

typedef struct Point Point;

Point * point_new(int x, int y);

and then provide the struct definition in the implementation file:

struct Point
{
  int x, y;
};

Point * point_new(int x, int y)
{
  Point *p;
  if((p = malloc(sizeof *p)) != NULL)
  {
    p->x = x;
    p->y = y;
  }
  return p;
}

In this latter case, you cannot return the Point by value, since its definition is hidden from users of the header file. This is a technique used widely in GTK+, for instance.

UPDATE Note that there are also highly-regarded C projects where this use of typedef to hide struct is considered a bad idea, the Linux kernel is probably the most well-known such project. See Chapter 5 of The Linux Kernel CodingStyle document for Linus' angry words. :) My point is that the "should" in the question is perhaps not set in stone, after all.

@dreamlax 2011-01-06 10:40:44

You shouldn't use identifiers with an underscore followed by an uppercase letter, they are reserved (see section 7.1.3 paragraph 1). Although unlikely to be much of a problem, it is technically undefined behaviour when you use them (7.1.3 paragraph 2).

@dlchambers 2011-10-04 12:10:26

How about the pros/cons of this syntax: typedef struct Point { int x, y; } Point This link: en.wikipedia.org/wiki/Struct_(C_programming_language)#typede‌​f discusses the issue but is ambiguous as to whether it's in or out of favor

@dlchambers 2011-10-04 12:14:12

Answer to my own question: stackoverflow.com/questions/1110944/…

@brianmearns 2012-01-16 17:08:56

@dreamlax: In case it wasn't clear to others, that's only starting an identifier with an underscore and an upper case that you shouldn't do; you're free to use that in the middle of an identifier.

@William Pursell 2012-01-25 14:15:10

It's interesting that the example given here (in which the typedef prevents using "struct" "all over the place") is actually longer than the same code without the typedef, since it saves exactly one use of the word "struct". The smidgen of abstraction gained rarely compares favorable with the additional obfuscation.

@unwind 2012-12-18 15:54:17

@WilliamPursell How do you count to get one? I see three; one in the header and two in the implementation file. Maybe I'm just confused.

@William Pursell 2012-12-23 17:01:09

@unwind Many months have passed, so I cannot be sure of what I was thinking, and I agree with your count. Perhaps I was thinking of the following very poor style: header file with just struct point * point_new(int x, int y); (combining the forward declaration of the struct with the function declaration) and implementation file struct point { int x,y; } * point_new( ... (combining the struct definition with the function declaration).

@Rerito 2013-01-30 21:42:38

@dreamlax I recall that many Gstreamer code defines structures with an alias following the pattern _[A-Z].* ... And it works very well. Could you explain a little more (a link in comment would satisfy me). Btw, sorry for the "necromancing"

@dreamlax 2013-01-30 22:10:42

@Rerito: It's usually no big deal. Identifiers such as _[A-Z_].* are reserved for future use. For example, C99 introduced _Bool and C11 introduced _Atomic and _Thread_local (among many others). All of these were named this way because they were out of the "reserved" pool, and anyone who already used these keywords/identifiers in their own code violated a rule. It usually poses no risk to use _StructName etc. Technically according to the standard, it is undefined behaviour to use a name like that, but I've yet to encounter a situation where it mattered.

@Ring Ø 2013-04-15 04:41:27

@Rerito fyi, page 166 of C99 draft, All identifiers that begin with an underscore and either an uppercase letter or another underscore are always reserved for any use. And All identifiers that begin with an underscore are always reserved for use as identifiers with file scope in both the ordinary and tag name spaces.

@gsingh2011 2013-05-29 00:13:42

Interestingly enough, the linux kernel coding guidelines say we should be a lot more conservative about using typedefs (section 5): kernel.org/doc/Documentation/CodingStyle

@cubuspl42 2014-07-05 16:28:16

@dreamlax "You shouldn't use identifiers with an underscore followed by an uppercase letter". Is it about names with underscore followed by an uppercase or beginning with underscore followed by an uppercase? ring0 suggests that it's the latter, but after reading your comment I thought that it's the first.

@alternative 2015-03-19 21:37:13

Anyone who uses typedefs like this is stupid, I hate people like this, you can't even remove the typedef.... It provides no abstraction and is the most useless thing. Please never do this, and if you have to, put the god dang typedefs in a separate header and don't force me to use it. Because I don't want them.

@supercat 2015-03-27 18:53:03

@alternative: In some implementations, a type like FILE would be better as a struct; in others, it would be better as a union. If in a particular implementation it would be better as a union, having client code say struct FILE * everywhere would force the implementation to wrap the union in a useless single-member structure.

@alternative 2015-04-03 14:45:36

@supercat standard library is excused from this...

@supercat 2015-04-03 15:58:44

@alternative: Why only the "standard" library? I would think many sorts of libraries could plausibly be best served in some implementation by having a union as an outer member, and in others by having a struct. Personally I think it would have been better if rather than having union types, C had provided more detailed control over structure layout (e.g. struct quad { unsigned long l; unsigned char b[4] @ l;}) in which case then the issue would be moot [actually, C would still benefit from that], but that's obviously not what happened.

@alternative 2015-04-09 20:03:49

@supercat but whether a non-opaque object is a struct or union is important, you should be able to immediately tell. If its opaque its not as much of an issue, and everything in standard library is opaque

@supercat 2015-04-09 20:21:15

@alternative: If a type has more than one non-opaque field, then whether it's a struct or union is obviously important. I don't see any reason that the C standard should be unique in having opaque or nearly-opaque types which do not expose more than one field.

@Milhous 2015-10-13 01:07:31

Your first example the first function declares a local variable and it returns that variable (Point a). This will generate a warning and is an error. stackoverflow.com/questions/4824342/…

@unwind 2015-10-14 09:21:30

@Milhous Not at all, I'm returning a value and not a pointer.

@Milhous 2015-10-21 01:53:19

@unwind Ah, you are correct. but using values is a very bad practice in general. Inside the method it will copy all the data. You example this is ok as there are 8 bytes. But imagine if it were several megabytes.

@unwind 2015-10-22 08:55:23

@Milhous That's just borkened reasoning in my opinion. A Point is not several megabytes. Returning values is awesome for semantics and readability, and being super-ultra-hyper-defensive and thinking "oh noes, some programs manipulate data that is too large to be returned, let's never return values" makes no sense to me. Use the right tool etc.

@PSkocik 2016-10-31 19:51:46

@unwind +1 Value returning functions also have the benefit that they can be marked __attribute__((const)) or pure, both of which don't work well with functions that return via a pointer parameter. It's unfortunate though, that plain C compilers don't do RVO well (=at all) on this. I played with this once and g++ had a couple of percentage points faster returns by value because of the RVO-avoided copying.

@Akshay Immanuel D 2018-07-17 11:26:25

In the first code snippet, is'nt it misleading to return a struct allocated on stack?

@BinaryTreeee 2018-11-23 12:44:12

I don't understand your In this latter case, you cannot return the Point by value, since its declaration is hidden from users of the header file. part, why it's related to typedef?

@Quark 2019-06-23 09:23:41

Though not related to the question, can you tell me how if((p = malloc(sizeof *p)) != NULL) works here? Thanks in advance.

@unwind 2019-06-24 08:34:00

@AkshayImmanuelD No, since the struct is treated as a value, it's no different from returning an integer (compare const int x = 17; return x;). The entire value is copied, by value, no pointers are involved so where the original was stored doesn't matter.

@unwind 2019-06-24 08:34:57

@taritgoswami What part is confusing? The expression sizeof *p is a compile-time way to compute the number of bytes required to store whatever p is pointing at, and removes the need to manually enter the type name an extra time.

@Quark 2019-06-24 19:28:29

Thanks, and when the (p = malloc(sizeof *p)) expression can be NULL ?

@unwind 2019-06-26 08:01:57

@taritgoswami The malloc() function returns NULL if it fails to allocate the requested amount of memory. This is basic C knowledge.

@natersoz 2010-05-29 07:12:11

I don't think forward declarations are even possible with typedef. Use of struct, enum, and union allow for forwarding declarations when dependencies (knows about) is bidirectional.

Style: Use of typedef in C++ makes quite a bit of sense. It can almost be necessary when dealing with templates that require multiple and/or variable parameters. The typedef helps keep the naming straight.

Not so in the C programming language. The use of typedef most often serves no purpose but to obfuscate the data structure usage. Since only { struct (6), enum (4), union (5) } number of keystrokes are used to declare a data type there is almost no use for the aliasing of the struct. Is that data type a union or a struct? Using the straightforward non-typdefed declaration lets you know right away what type it is.

Notice how Linux is written with strict avoidance of this aliasing nonsense typedef brings. The result is a minimalist and clean style.

@GManNickG 2010-05-29 07:14:59

Clean would be not repeating structeverywhere... Typedef's make new types. What do you use? Types. We don't care if it's a struct, union, or enum, that's why we typedef it.

@Bernd Jendrissek 2012-11-26 03:59:13

No, we do care if it's a struct or union, versus an enum or some atomic type. You can't coerce a struct to an integer or to a pointer (or to any other type, for that matter), which is all you sometimes have to store some context. Having the 'struct' or 'union' keywords around improves locality of reasoning. Nobody says you need to know what's inside the struct.

@supercat 2015-03-27 18:54:07

@BerndJendrissek: Structs and unions are different from other types, but should client code care about which of those two things (struct or union) something like a FILE is?

@Bernd Jendrissek 2015-03-29 17:16:38

@supercat FILE is a good use of typedef. I think that typedef is overused, not that it's a misfeature of the language. IMHO using typedef for everything is the "speculative overgenerality" code smell. Notice that you declare variables as FILE *foo, never as FILE foo. To me, this matters.

@supercat 2015-03-29 17:36:03

@BerndJendrissek: If file-identifying variables were of type FILE rather than FILE*, it would be unclear when/whether methods should use parameters of type FILE versus FILE*. In Pascal, the normal mode of usage would be to have variables of the type itself, but have methods take by-reference parameters of that type; C doesn't have by-reference parameters, though [I vaguely recall Pascal won't allow a variable of type File or Text to be passed by value, thus avoiding any ambiguity as to what such a thing should mean].

@supercat 2015-03-29 17:45:35

@BerndJendrissek: BTW, I personally wonder whether union types offer any advantages, in either programmer-friendliness or compiler simplicity, versus having a means of explicitly aliasing structure members? I would think an aliasing mechanism would be simpler for a compiler to implement, and more useful for programmers, especially if bitfields were subsumed into that, e.g. int mode_settings; unsigned mode @mode_settings.0:4; unsigned enable @mode_settings.31:1;. I don't know if any compilers presently use @ within structures in a way that would contradict that, but...

@supercat 2015-03-29 17:48:32

...adding a syntax like that to the language could be helpful even today since it would provide a portable means of declaring bitfields.

@Bernd Jendrissek 2015-03-30 18:47:09

@supercat: "If file-identifying variables were of type FILE rather than FILE* ..." But that's exactly the ambiguity that typedefs enable! We're just used to fopen taking a FILE * so we don't fret about it, but each time you add typedef you're introducing yet another bit of cognitive overhead: does this API want foo_t args or foo_t *? Explicitly carrying the 'struct' along improves locality of reasoning, if at the cost of a few more characters per function definition.

@supercat 2015-03-30 19:18:29

@BerndJendrissek: A problem with carrying the struct notation along is that in many cases it should be possible for the implementation to use a union rather than a struct without the client code having to care. If C had omitted union types but instead included a means of explicitly aliasing struct fields, then that wouldn't be an issue, but as it is struct and union types are distinct. The client API should care that FILE isn't typedef'ed as an array (those behave weirdly) but otherwise shouldn't care what it is.

@user1533288 2013-08-11 15:48:27

It turns out that there are pros and cons. A useful source of information is the seminal book "Expert C Programming" (Chapter 3). Briefly, in C you have multiple namespaces: tags, types, member names and identifiers. typedef introduces an alias for a type and locates it in the tag namespace. Namely,

typedef struct Tag{
...members...
}Type;

defines two things. One Tag in the tag namespace and one Type in the type namespace. So you can do both Type myType and struct Tag myTagType. Declarations like struct Type myType or Tag myTagType are illegal. In addition, in a declaration like this:

typedef Type *Type_ptr;

we define a pointer to our Type. So if we declare:

Type_ptr var1, var2;
struct Tag *myTagType1, myTagType2;

then var1,var2 and myTagType1 are pointers to Type but myTagType2 not.

In the above-mentioned book, it mentions that typedefing structs are not very useful as it only saves the programmer from writing the word struct. However, I have an objection, like many other C programmers. Although it sometimes turns to obfuscate some names (that's why it is not advisable in large code bases like the kernel) when you want to implement polymorphism in C it helps a lot look here for details. Example:

typedef struct MyWriter_t{
    MyPipe super;
    MyQueue relative;
    uint32_t flags;
...
}MyWriter;

you can do:

void my_writer_func(MyPipe *s)
{
    MyWriter *self = (MyWriter *) s;
    uint32_t myFlags = self->flags;
...
}

So you can access an outer member (flags) by the inner struct (MyPipe) through casting. For me it is less confusing to cast the whole type than doing (struct MyWriter_ *) s; every time you want to perform such functionality. In these cases brief referencing is a big deal especially if you heavily employ the technique in your code.

Finally, the last aspect with typedefed types is the inability to extend them, in contrast to macros. If for example, you have:

#define X char[10] or
typedef char Y[10]

you can then declare

unsigned X x; but not
unsigned Y y;

We do not really care for this for structs because it does not apply to storage specifiers (volatile and const).

@Jonathon Reinhart 2015-06-01 19:18:13

MyPipe *s; MyWriter *self = (MyWriter *) s; and you've just broken strict aliasing.

@underscore_d 2016-04-09 16:35:07

@JonathonReinhart It would be illustrative to mention how this can be avoided, for example how the hugely cast-happy GTK+ works around it: bugzilla.gnome.org/show_bug.cgi?id=140722 / mail.gnome.org/archives/gtk-devel-list/2004-April/msg00196.h‌​tml

@Qwertyzw 2018-05-11 13:39:00

"typedef introduces an alias for a type and locates it in the tag namespace. Namely" typedef struct Tag{ ...members... }Type; "defines two things" doesn't quite make sense. if typedef defines tags then 'Type' here should also be a tag. The truth is the definition defines 2 tags and 1 type (or 2 types and 1 tag. not sure): struct Tag, Tag and Type. struct Tag is definitely a type. Tag is a tag. but the confusion is whether Type is a tag or a type

@Asif 2018-03-09 18:16:39

Let's start with the basics and work our way up.

Here is an example of Structure definition:

struct point
  {
    int x, y;
  };

Here the name point is optional.

A Structure can be declared during its definition or after.

Declaring during definition

struct point
  {
    int x, y;
  } first_point, second_point;

Declaring after definition

struct point
  {
    int x, y;
  };
struct point first_point, second_point;

Now, carefully note the last case above; you need to write struct point to declare Structures of that type if you decide to create that type at a later point in your code.

Enter typedef. If you intend to create new Structure ( Structure is a custom data-type) at a later time in your program using the same blueprint, using typedef during its definition might be a good idea since you can save some typing moving forward.

typedef struct point
  {
    int x, y;
  } Points;

Points first_point, second_point;

A word of caution while naming your custom type

Nothing prevents you from using _t suffix at the end of your custom type name but POSIX standard reserves the use of suffix _t to denote standard library type names.

@RichardGeerify 2016-06-11 00:50:08

In 'C' programming language the keyword 'typedef' is used to declare a new name for some object(struct, array, function..enum type). For example, I will use a 'struct-s'. In 'C' we often declare a 'struct' outside of the 'main' function. For example:

struct complex{ int real_part, img_part }COMPLEX;

main(){

 struct KOMPLEKS number; // number type is now a struct type
 number.real_part = 3;
 number.img_part = -1;
 printf("Number: %d.%d i \n",number.real_part, number.img_part);

}

Each time I decide to use a struct type I will need this keyword 'struct 'something' 'name'.'typedef' will simply rename that type and I can use that new name in my program every time I want. So our code will be:

typedef struct complex{int real_part, img_part; }COMPLEX;
//now COMPLEX is the new name for this structure and if I want to use it without
// a keyword like in the first example 'struct complex number'.

main(){

COMPLEX number; // number is now the same type as in the first example
number.real_part = 1;
number.img)part = 5;
printf("%d %d \n", number.real_part, number.img_part);

}

If you have some local object(struct, array, valuable) that will be used in your entire program you can simply give it a name using a 'typedef'.

@JamesAD-0 2017-07-05 00:19:12

A> a typdef aids in the meaning and documentation of a program by allowing creation of more meaningful synonyms for data types. In addition, they help parameterize a program against portability problems (K&R, pg147, C prog lang).

B> a structure defines a type. Structs allows convenient grouping of a collection of vars for convenience of handling (K&R, pg127, C prog lang.) as a single unit

C> typedef'ing a struct is explained in A above.

D> To me, structs are custom types or containers or collections or namespaces or complex types, whereas a typdef is just a means to create more nicknames.

@Michael Burr 2008-10-31 17:12:55

From an old article by Dan Saks (http://www.ddj.com/cpp/184403396?pgno=3):


The C language rules for naming structs are a little eccentric, but they're pretty harmless. However, when extended to classes in C++, those same rules open little cracks for bugs to crawl through.

In C, the name s appearing in

struct s
    {
    ...
    };

is a tag. A tag name is not a type name. Given the definition above, declarations such as

s x;    /* error in C */
s *p;   /* error in C */

are errors in C. You must write them as

struct s x;     /* OK */
struct s *p;    /* OK */

The names of unions and enumerations are also tags rather than types.

In C, tags are distinct from all other names (for functions, types, variables, and enumeration constants). C compilers maintain tags in a symbol table that's conceptually if not physically separate from the table that holds all other names. Thus, it is possible for a C program to have both a tag and an another name with the same spelling in the same scope. For example,

struct s s;

is a valid declaration which declares variable s of type struct s. It may not be good practice, but C compilers must accept it. I have never seen a rationale for why C was designed this way. I have always thought it was a mistake, but there it is.

Many programmers (including yours truly) prefer to think of struct names as type names, so they define an alias for the tag using a typedef. For example, defining

struct s
    {
    ...
    };
typedef struct s S;

lets you use S in place of struct s, as in

S x;
S *p;

A program cannot use S as the name of both a type and a variable (or function or enumeration constant):

S S;    // error

This is good.

The tag name in a struct, union, or enum definition is optional. Many programmers fold the struct definition into the typedef and dispense with the tag altogether, as in:

typedef struct
    {
    ...
    } S;

The linked article also has a discussion about how the C++ behavior of not requireing a typedef can cause subtle name hiding problems. To prevent these problems, it's a good idea to typedef your classes and structs in C++, too, even though at first glance it appears to be unnecessary. In C++, with the typedef the name hiding become an error that the compiler tells you about rather than a hidden source of potential problems.

@Jonathan Leffler 2016-06-05 22:02:49

One example of where the tag name is the same as a non-tag name is in (POSIX or Unix) program with the int stat(const char *restrict path, struct stat *restrict buf) function. There you have a function stat in the ordinary name space and struct stat in the tag name space.

@eRaisedToX 2016-08-03 07:24:49

your statement , S S; // error .... IS WRONG It works well. I mean your statement that "we cant have same name for typedef tag and var" is WRONG... pls check

@Aaron Franke 2018-11-16 07:00:03

"declarations such as .. are errors in C" Why? It isn't in C++ or C#. Why is C designed this way?

@Matthew Corey Brown 2016-11-02 09:34:21

Turns out in C99 typedef is required. It is outdated, but a lot of tools (ala HackRank) use c99 as its pure C implementation. And typedef is required there.

I'm not saying they should change (maybe have two C options) if the requirement changed, those of us studing for interviews on the site would be SOL.

@Julien Lopez 2016-11-02 09:54:46

"Turns out in C99 typedef is required." What do you mean?

@YoYoYonnY 2016-11-30 21:26:56

The question is about C, not C++. In C typedefs are 'required' (and will most likely always be). 'Required' as in, you will not be able to declare a variable Point varName; and have the type be synonymous with struct Point; without a typedef struct Point Point;.

@natersoz 2016-01-30 15:47:18

typedef will not provide a co-dependent set of data structures. This you cannot do with typdef:

struct bar;
struct foo;

struct foo {
    struct bar *b;
};

struct bar {
    struct foo *f;
};

Of course you can always add:

typedef struct foo foo_t;
typedef struct bar bar_t;

What exactly is the point of that?

@cschol 2009-03-31 00:00:32

One other good reason to always typedef enums and structs results from this problem:

enum EnumDef
{
  FIRST_ITEM,
  SECOND_ITEM
};

struct StructDef
{
  enum EnuumDef MyEnum;
  unsigned int MyVar;
} MyStruct;

Notice the typo in EnumDef in the struct (EnuumDef)? This compiles without error (or warning) and is (depending on the literal interpretation of the C Standard) correct. The problem is that I just created an new (empty) enumeration definition within my struct. I am not (as intended) using the previous definition EnumDef.

With a typdef similar kind of typos would have resulted in a compiler errors for using an unknown type:

typedef 
{
  FIRST_ITEM,
  SECOND_ITEM
} EnumDef;

typedef struct
{
  EnuumDef MyEnum; /* compiler error (unknown type) */
  unsigned int MyVar;
} StructDef;
StrructDef MyStruct; /* compiler error (unknown type) */

I would advocate ALWAYS typedef'ing structs and enumerations.

Not only to save some typing (no pun intended ;)), but because it is safer.

@M.M 2015-02-14 22:15:17

Even worse, your typo might coincide with a different tag. In the case of a struct this could result in the entire program compiling correctly and having runtime undefined behaviour.

@user3629249 2015-05-28 20:57:05

this definition: 'typedef { FIRST_ITEM, SECOND_ITEM } EnumDef;' does not define an enum. I've written hundreds of huge programs and had the mis-fortune to perform maintenance on programs others have written. From the hard hand of experience, using typedef on a struct only leads to problems. Hopefully the programmer is not so handicapped that they have problems typing a full definition when they declare a struct instance. C is not Basic, so typing some more characters is not detrimental to the operation of the program.

@user3629249 2015-05-28 20:59:35

For those that feel some abhorrence to typing more than the absolute minimum number of characters, may I suggest joining some group that tries to write applications with the minimum number of keystrokes. Just don't use their new 'skill' in a work environment, especially a work environment that rigorously performs peer reviews

@YoYoYonnY 2016-11-30 21:31:59

Note, it is usually discouraged to use enum as a type, as many compilers emit strange warnings when using them 'wrong'. For example, initializing an enum to 0 might give an 'integer constant not in enum' warning. Forward-declaring an enum is also not allowed. One should use int (or unsigned int) instead.

@natersoz 2017-01-21 19:49:31

That example does not compile , nor would I expect it to. Compiling Debug/test.o test.c:10:17: error: field has incomplete type 'enum EnuumDef' enum EnuumDef MyEnum; ^ test.c:10:8: note: forward declaration of 'enum EnuumDef' enum EnuumDef MyEnum; ^ 1 error generated. gnuc, with std=c99.

@mja 2018-06-19 02:30:34

In clang ang gcc with c99, that example does not compile. But seems like Visual Studio does not complain anything. rextester.com/WDQ5821

@Jerry Hicks 2010-12-30 21:20:44

It's amazing how many people get this wrong. PLEASE don't typedef structs in C, it needlessly pollutes the global namespace which is typically very polluted already in large C programs.

Also, typedef'd structs without a tag name are a major cause of needless imposition of ordering relationships among header files.

Consider:

#ifndef FOO_H
#define FOO_H 1

#define FOO_DEF (0xDEADBABE)

struct bar; /* forward declaration, defined in bar.h*/

struct foo {
  struct bar *bar;
};

#endif

With such a definition, not using typedefs, it is possible for a compiland unit to include foo.h to get at the FOO_DEF definition. If it doesn't attempt to dereference the 'bar' member of the foo struct then there will be no need to include the "bar.h" file.

Also, since the namespaces are different between the tag names and the member names, it is possible to write very readable code such as:

struct foo *foo;

printf("foo->bar = %p", foo->bar);

Since the namespaces are separate, there is no conflict in naming variables coincident with their struct tag name.

If I have to maintain your code, I will remove your typedef'd structs.

@William Pursell 2012-01-25 14:04:41

What's more amazing is that 13 months after this answer is given, I'm the first to upvote it! typedef'ing structs is one of the greatest abuses of C, and has no place in well-written code. typedef is useful for de-obfuscating convoluted function pointer types and really serves no other useful purpose.

@Jens 2012-03-14 10:31:18

Peter van der Linden also makes a case against typedefing structs in his enlightening book "Expert C Programming - Deep C Secrets". The gist is: You WANT to know that something is a struct or union, not HIDE it.

@jasso 2012-12-09 22:39:29

The Linux kernel coding style explicitly forbids typedefing structs. Chapter 5: Typedefs: "It's a mistake to use typedef for structures and pointers." kernel.org/doc/Documentation/CodingStyle

@Pavel Minaev 2013-03-20 07:18:00

What benefits, exactly, does typing "struct" over and over again provide? And speaking of pollution, why would you want to have a struct and a function/variable/typedef with the same name in a global namespace (unless it's a typedef for that same function)? The safe pattern is to use typedef struct X { ... } X. That way you can use the short form X to address the struct anywhere the definition is available, but can still forward-declare and use struct X when desired.

@Nathan Day 2013-06-01 10:26:01

I personal very rarely if ever use typedef, I wouldn't say other people shouldn't use it, it just not my style. I like to see a struct before a variable type so I know straight away its a struct. The easier to type argument is a bit lame, having variable that are a single letter is also easier to type, also with auto completions how hard is it to type struct nowadays anywhere.

@M.M 2014-11-06 01:53:00

What is supposed to be the problem with foo.h in this example? You can still access FOO_DEF if you changed to typedef struct { struct bar *bar; } foo;

@Janus Troelsen 2015-02-14 21:53:13

@MattMcNabb I also do not understand this, did you figure it out?

@M.M 2015-02-14 21:54:37

@JanusTroelsen Yes, I see now: it's supposed to be contrasted with struct foo { Bar *bar; }; which would require foo.h to include bar.h.

@user3629249 2015-05-28 20:43:36

this line: ';typedef struct Point Point;' clearly makes my 'Point' about not typedef'ing a struct. The first 'Point' is a struct tag name. The second 'Point' is a 'new' type. Now, you, the compiler, and anyone else that reads the code needs to keep track of which 'Point' is meant.

@Yawar 2016-12-04 05:43:33

@user3629249 it shouldn't be too difficult. The former will always be preceded by the struct keyword.

@Daniel 2017-02-22 18:34:12

"What benefits, exactly, does typing "struct" over and over again provide?" --- Keeps the fingers healthy through lots of exercise.

@Lorinczy Zsigmond 2017-05-04 10:43:10

Sorry, added a -1 :( as typedef-ing doesn't prevent any good thing you have mentioned, eg in header opaque.h: typedef struct Opaque Opaque; extern Opaque *OpConstructor (void); extern void OpDestructor (Opaque *); then in opaque.c: struct Opaque { actual definition };

@Yu Hao 2013-08-07 14:19:02

Linux kernel coding style Chapter 5 gives great pros and cons (mostly cons) of using typedef.

Please don't use things like "vps_t".

It's a mistake to use typedef for structures and pointers. When you see a

vps_t a;

in the source, what does it mean?

In contrast, if it says

struct virtual_container *a;

you can actually tell what "a" is.

Lots of people think that typedefs "help readability". Not so. They are useful only for:

(a) totally opaque objects (where the typedef is actively used to hide what the object is).

Example: "pte_t" etc. opaque objects that you can only access using the proper accessor functions.

NOTE! Opaqueness and "accessor functions" are not good in themselves. The reason we have them for things like pte_t etc. is that there really is absolutely zero portably accessible information there.

(b) Clear integer types, where the abstraction helps avoid confusion whether it is "int" or "long".

u8/u16/u32 are perfectly fine typedefs, although they fit into category (d) better than here.

NOTE! Again - there needs to be a reason for this. If something is "unsigned long", then there's no reason to do

typedef unsigned long myflags_t;

but if there is a clear reason for why it under certain circumstances might be an "unsigned int" and under other configurations might be "unsigned long", then by all means go ahead and use a typedef.

(c) when you use sparse to literally create a new type for type-checking.

(d) New types which are identical to standard C99 types, in certain exceptional circumstances.

Although it would only take a short amount of time for the eyes and brain to become accustomed to the standard types like 'uint32_t', some people object to their use anyway.

Therefore, the Linux-specific 'u8/u16/u32/u64' types and their signed equivalents which are identical to standard types are permitted -- although they are not mandatory in new code of your own.

When editing existing code which already uses one or the other set of types, you should conform to the existing choices in that code.

(e) Types safe for use in userspace.

In certain structures which are visible to userspace, we cannot require C99 types and cannot use the 'u32' form above. Thus, we use __u32 and similar types in all structures which are shared with userspace.

Maybe there are other cases too, but the rule should basically be to NEVER EVER use a typedef unless you can clearly match one of those rules.

In general, a pointer, or a struct that has elements that can reasonably be directly accessed should never be a typedef.

@Yawar 2016-12-04 05:48:03

'Opaqueness and "accessor functions" are not good in themselves'. Can someone explain why? I would think information hiding and encapsulation would be a very good idea.

@Baldrickk 2017-01-10 16:18:15

@Yawar I just read this document and had exactly the same thought. Sure, C isn't object orientated, but abstraction is still a thing.

@doccpu 2010-03-06 14:54:22

At all, in C language, struct/union/enum are macro instruction processed by the C language preprocessor (do not mistake with the preprocessor that treat "#include" and other)

so :

struct a
{
   int i;
};

struct b
{
   struct a;
   int i;
   int j;
};

struct b is expended as something like this :

struct b
{
    struct a
    {
        int i;
    };
    int i;
    int j;
}

and so, at compile time it evolve on stack as something like: b: int ai int i int j

that also why it's dificult to have selfreferent structs, C preprocessor round in a déclaration loop that can't terminate.

typedef are type specifier, that means only C compiler process it and it can do like he want for optimise assembler code implementation. It also dont expend member of type par stupidly like préprocessor do with structs but use more complex reference construction algorithm, so construction like :

typedef struct a A; //anticipated declaration for member declaration

typedef struct a //Implemented declaration
{
    A* b; // member declaration
}A;

is permited and fully functional. This implementation give also access to compilator type conversion and remove some bugging effects when execution thread leave the application field of initialisation functions.

This mean that in C typedefs are more near as C++ class than lonely structs.

@Bernd Jendrissek 2015-03-30 18:52:26

It isn't difficult to have self-referential structs at all. struct foo { struct foo *next; int thing; }

@underscore_d 2016-04-09 16:44:28

...what? Saying preprocessor to describe the resolution of structs and typedefs is bad enough, but the rest of your writing is so confusing that I find it hard to get any message from it. One thing I can say, though, is that your idea that a non-typedefd struct cannot be forward-declared or used as an opaque (pointer) member is totally false. In your 1st example, struct b can trivially contain a struct a *, no typedef required. The assertions that structs are merely dumb pieces of macro-expansion, and that typedefs give them revolutionary new powers, are painfully incorrect

@philsquared 2008-10-31 08:24:40

the name you (optionally) give the struct is called the tag name and, as has been noted, is not a type in itself. To get to the type requires the struct prefix.

GTK+ aside, I'm not sure the tagname is used anything like as commonly as a typedef to the struct type, so in C++ that is recognised and you can omit the struct keyword and use the tagname as the type name too:


    struct MyStruct
    {
      int i;
    };

    // The following is legal in C++:
    MyStruct obj;
    obj.i = 7;

@Greg Hewgill 2008-10-31 07:16:58

Using a typedef avoids having to write struct every time you declare a variable of that type:

struct elem
{
 int i;
 char k;
};
elem user; // compile error!
struct elem user; // this is correct

@Manoj Doubts 2008-10-31 12:03:14

ok we are not having that problem in C++. So why dont anybody remove that glitch from the C's compiler and make it the same as in C++.ok C++ is having some different application areas and so it is having the advanced features.but can we not inherit some of them in C without changing the original C?

@Michael Carman 2008-10-31 13:05:55

Manoj, the tag name ("struct foo") is necessary when you need to define a struct that references itself. e.g. the "next" pointer in a linked list. More to the point, the compiler implements the standard, and that's what the standard says to do.

@Herms 2008-10-31 19:36:02

It's not a glitch in the C compiler, it's part of the design. They changed that for C++, which I think makes things easier, but that doesn't mean C's behavior is wrong.

@user3629249 2015-05-28 20:50:28

unfortunately many 'programmers' define a struct then typedef it with some 'unrelated' name (like struct myStruct ...; typedef struct myStruct susan*; In almost all instances a typedef leads to nothing but cluttering the code, hiding the actual definition of a variable/parameter, and mis-leads everyone, including the original writer of the code.

Related Questions

Sponsored Content

13 Answered Questions

[SOLVED] What is a typedef enum in Objective-C?

5 Answered Questions

[SOLVED] What is the difference between 'typedef' and 'using' in C++11?

10 Answered Questions

[SOLVED] Improve INSERT-per-second performance of SQLite?

28 Answered Questions

[SOLVED] When to use struct?

  • 2009-02-06 17:37:55
  • Alex Baranosky
  • 252440 View
  • 1322 Score
  • 28 Answer
  • Tags:   c# struct

24 Answered Questions

[SOLVED] When should you use a class vs a struct in C++?

  • 2008-09-10 16:29:54
  • Alan Hinchcliffe
  • 369625 View
  • 865 Score
  • 24 Answer
  • Tags:   c++ oop class struct ooad

12 Answered Questions

[SOLVED] typedef struct vs struct definitions

  • 2009-11-04 17:21:57
  • user69514
  • 627899 View
  • 742 Score
  • 12 Answer
  • Tags:   c struct typedef

10 Answered Questions

8 Answered Questions

[SOLVED] Difference between 'struct' and 'typedef struct' in C++?

  • 2009-03-04 20:41:12
  • criddell
  • 478813 View
  • 781 Score
  • 8 Answer
  • Tags:   c++ struct typedef

2 Answered Questions

[SOLVED] Why is a typedef not allowed in the inner struct?

7 Answered Questions

[SOLVED] Why should structure names have a typedef?

  • 2010-04-09 07:15:04
  • Jay
  • 1340 View
  • 9 Score
  • 7 Answer
  • Tags:   c struct typedef

Sponsored Content