Hacker News Reader

Comment by imglorp | Hacker News Reader

Which is why it's nice to lift stuff out into typedefs. It centralizes them (DRY principle) and avoids this issue.

    typedef int thing_t;
    ...
    thing_t *foo;
    // code
    foo = malloc(sizeof(thing_t));

View on HN

Why is that better than just getting `sizeof(* foo)`? Even with typedef, I can see this happening in the future:

    typedef int thing_t;
    ...
    thing_t *foo_internal;
    thing_wrapper_t *foo;
    // code
    foo = malloc(sizeof(thing_t));

If you do:

    foo = malloc(sizeof(*foo));

That's at least always on the same line.

That just makes it more verbose.

This, on the other hand, always allocates one object of foo's pointed-to-size, whatever its type:

    foo = malloc(sizeof(*foo));

As an aside, I think nearly any time you want a typedef, it's worth wrapping it in a struct.

    typedef struct { int value; } thing_t;

That way the compiler catches it when you try to pass the wrong thing (at least, more of the time).

DRY is good, but making the structure of your code reflect the actual semantics you want is better. What you want is to allocate space for foo. So write that.

Well, in this (simple) case you can just do

    int *foo;
    foo = malloc(sizeof(*foo));

And avoid the brittleness mentioned.

Reply on news.ycombinator.com