typedef

What typedef does NOT do, with proof

It does not create a new type. The name is an alias, and the two are the same type for every purpose the language has.

#include <stdio.h>

typedef int Metres;
typedef int Feet;

int main(void)
{
    Metres distance = 100;
    Feet height = 6;

    /* Nonsense, and the compiler has no objection: both are int. */
    int nonsense = distance + height;

    printf("adding metres to feet gives %d, and -Wall -Wextra said nothing\n",
           nonsense);
    return 0;
}

adding metres to feet gives 106, and -Wall -Wextra said nothing

That program compiles clean. Adding metres to feet is meaningless and the compiler cannot know it, because Metres and Feet are both spellings of int. So typedef is documentation, not protection. If you need the compiler to keep two quantities apart, you need two different structure types, which is chapter 42.

It does not allocate anything. typedef is a declaration, not a definition of an object. No memory is set aside.

It cannot extend a type. typedef cannot make an integer bigger or add an operation. It only renames.

It is not a macro. The pointer example above is the proof. typedef is handled by the compiler and understands the grammar of declarations; #define is handled by the preprocessor and understands only text.

Where typedef really earns its place

Three uses account for nearly all of it in real C.

1. Shortening a structure name. In C, a structure's name includes the keyword: struct student. A typedef lets you write Student. This is the commonest use by a wide margin, and chapter 42 gives it.

2. Naming a pointer-to-function type, which is otherwise unreadable.

typedef int (*Comparison)(const void *, const void *);

3. Making a program's own vocabulary portable. The standard library does this everywhere, and you have already used the results: size_t is a typedef for whatever unsigned type is right for a size on this machine, and FILE, time_t, ptrdiff_t and wchar_t are all typedef names. That is why sizeof prints with %zu and not %u: the actual type behind size_t differs between machines, and the typedef is what lets your program not care.

That last point is the honest answer to "why does typedef exist": it lets a program name a type by its purpose while the compiler chooses the representation.

Naming style

There is no rule, and there are two common conventions.

• Capitalised: Marks, Percentage, Student. Used in this book, because it makes a type name visible at a glance.
• _t suffix: marks_t, student_t. Common in systems code, and it imitates the library's size_t and time_t.

Strictly, names ending in _t are reserved by POSIX for the system's own headers, so the capitalised form is the safer habit. Either way, be consistent within a program.

Quick revision

• typedef existing-type new-name; gives a type a second name.
• The trick: write the variable declaration, put typedef in front, and the name declared becomes a type name.
• It creates no new type: sizeof proves it, and two typedef names for int add together without complaint.
• It allocates nothing and is handled by the compiler, not the preprocessor.
• Unlike #define, it knows it is declaring a type, so IntPtr p, q; makes two pointers.
• It obeys scope, so a typedef inside a function is local to it.
• Main uses: shortening struct names, naming function-pointer types, and giving a portable name to a machine-dependent type. size_t, FILE and time_t are library typedefs.

Test yourself

1. Write a typedef that names the type "array of 10 double", and declare two such arrays with it.

typedef double Vector[10];
Vector a, b;

2. Is sizeof(Marks) the same as sizeof(unsigned int) after typedef unsigned int Marks;?

Yes. Marks is another name for unsigned int, not a new type.

3. What is wrong with #define IntPtr int * followed by IntPtr p, q;?

It expands to int * p, q;, so p is a pointer and q is a plain int. A typedef would have made both pointers.

4. Will the compiler stop you adding a Metres to a Feet if both are typedef int?

No. They are the same type, so there is nothing for it to object to. Use two distinct structure types if you want that checked.

5. Name three typedef names from the standard library and say why each is a typedef rather than a fixed type.

size_t, time_t and FILE. Each hides a representation that differs between implementations, so a program can name the purpose and let the library choose the type.

6. Can a typedef be written inside a function?

Yes, and it then obeys the same scope rules as any other declaration in that block: it is visible from that point to the end of the block and nowhere else.

What can be asked on this, and how to answer it

"What is typedef? Explain with an example." Define it as a way of giving an existing type an additional name, give the syntax, give two examples of which one is an array or pointer type, and say plainly that no new type is created. The last part is where the marks separate.

"Distinguish between typedef and #define." Give the table's rows: compiler against preprocessor, type-aware against text substitution, scoped against not scoped, and the pointer example where the two genuinely differ.

"What are the advantages of typedef?" Readability, because a declaration can name the purpose of a value; brevity, because struct student becomes Student; portability, because a program can use a name whose underlying type the implementation chooses; and maintainability, because a representation can be changed in one line.

"Does typedef create a new data type?" No. It creates a new name for an existing type. The two names are interchangeable everywhere, and the compiler will not distinguish values of them.