Why is it necessary to cast NULL to a type in this macro?

Question

I have a question about some code in Eric Roberts' Programming Abstractions in C. He use several libraries of his own both to simplify things for readers and to teach how to write libraries. (All of the library code for the book can be found on this site.)

One library, genlib provides a macro for generic allocation of a pointer to a struct type. I don't understand part of the macro. I'll copy the code below, plus an example of how it is meant to be used, then I'll explain my question in more detail.

/*
 * Macro: New
 * Usage: p = New(pointer-type);
 * -----------------------------
 * The New pseudofunction allocates enough space to hold an
 * object of the type to which pointer-type points and returns
 * a pointer to the newly allocated pointer.  Note that
 * "New" is different from the "new" operator used in C++;
 * the former takes a pointer type and the latter takes the
 * target type.
 */

#define New(type) ((type) GetBlock(sizeof *((type) NULL)))

/* GetBlock is a wrapper for malloc. It encasulates the 
 * common sequence of malloc, check for NULL, return or
 * error out, depending on the NULL check. I'm not going
 * to copy that code since I'm pretty sure it isn't
 * relevant to my question. It can be found here though:
 * ftp://ftp.awl.com/cseng/authors/roberts/cs1-c/standard/genlib.c
 */

Roberts intends for the code to be used as follows:

    typedef struct {
        string name;
        /* etc. */
    } *employeeT;
    employeeT emp;
    emp = New(employeeT);

He prefers to use a pointer to the record as the type name, rather than the record itself. So New provides a generic way to allocate such struct records.

In the macro New, what I don't understand is this: sizeof *((type)) NULL). If I'm reading that correctly, it says "take the size of the dereferenced cast of NULL to whatever struct type type represents in a given call". I think I understand the dereferencing: we want to allocate enough space for the struct; the size of the pointer is not what we need, so we dereference to get at the size of the underlying record-type. But I don't understand the idea of casting NULL to a type.

My questions:

1. You can cast NULL? What does that even mean?

2. Why is the cast necessary? When I tried removing it, the compiler says error: expected expression. So, sizeof *(type) is not an expression? That confused me since I can do the following to get the sizes of arbitrary pointers-to-structs:

   #define struct_size(s_ptr) do { \
       printf("sizeof dereferenced pointer to struct %s: %lu\n", \
              #s_ptr, sizeof *(s_ptr)); \
   } while(0)
   

Edit: As many people point out below, the two examples aren't the same:

/* How genlib uses the macro. */
New(struct MyStruct*)
/* How I was using my macro. */
struct MyStruct *ptr; New(ptr)

For the record, this isn't homework. I'm an amateur trying to improve at C. Also, there's no problem with the code, as far as I can tell. That is, I'm not asking how I can do something different with it. I'm just trying to better understand (1) how it works and (2) why it must be written the way it is. Thanks.

Answer 1

The issue is that the macro needs to get the size of the type pointed at by the pointer type.

As an example, suppose that you have the the pointer type struct MyStruct*. Without removing the star from this expression, how would you get the size of struct MyStruct? You couldn't write

sizeof(*(struct MyStruct*))

since that's not legal C code.

On the other hand, if you had a variable of type struct MyStruct*, you could do something like this:

struct MyStruct* uselessPointer;
sizeof(*uselessPointer);

Since sizeof doesn't actually evaluate its argument (it just determines the static size of the type of the expression), this is safe.

Of course, in a macro, you can't define a new variable. However, you could make up a random pointer to a struct MyStruct* by casting an existing pointer. Here, NULL is a good candidate - it's an existing pointer that you can legally cast to a struct MyStruct*. Therefore, if you were to write

sizeof(* ((struct MyStruct*)NULL))

the code would

1. Cast NULL to a struct MyStruct*, yielding a pointer of static type struct MyStruct*.
2. Determine the size of the object that would be formed by dereferencing the pointer. Since the pointer has type struct MyStruct*, it points at an object of type struct MyStruct, so this yields the type of struct MyStruct.

In other words, it's a simple way to get an object of the pointer type so that you can dereference it and obtain an object of the underlying type.

I've worked with Eric on some other macros and he is a real pro with the preprocessor. I'm not surprised that this works, and I'm not surprised that it's tricky, but it certainly is clever!

As a note - in C++, this sort of trick used to be common until the introduction of the declval utility type, which is a less-hacky version of this operation.

Hope this helps!