Typedef


typedef is a reserved keyword in the programming languages C and C++. It is used to create an additional name for another data type, but does not create a new type. As such, it is often used to simplify the syntax of declaring complex data structures consisting of struct and union types, but is just as common in providing specific descriptive type names for integer data types of varying lengths.

Syntax

The syntax of the typedef declaration is:
; type-declaration;
The name of the new type alias follows the same syntax as declaring any other C identifier, therefore, in more detailed form:
; type-definition identifier
In the C standard library and in POSIX specifications the identifier for the typedef definition is often suffixed with, such as in size_t and time_t. This is practiced in other coding systems, although POSIX explicitly reserves this practice for POSIX data types.

Examples

typedef int length;
This creates the type as a synonym of the type.

Documentation use

A typedef declaration may be used as documentation by indicating the meaning of a variable within the programming context, e.g., it may include the expression of a unit of measurement or counts. The generic declarations,

int current_speed;
int high_score;
void congratulate

may be expressed by declaring context specific types:

typedef int km_per_hour;
typedef int points;
// `km_per_hour` is synonymous with `int` here, and thus, the compiler treats
// our new variables as integers.
km_per_hour current_speed;
points high_score;
void congratulate

Both sections of code execute identically. However, the use of typedef declarations in the second code block make it clear that the two variables, while representing the same data type, store different or incompatible data. The definition in of indicates to the programmer that should not be passed as an argument. This would not be as apparent if both were declared as variables of datatype. However, the indication is for the programmer only; the C/C++ compiler considers both variables to be of type and does not flag type mismatch warnings or errors for "wrong" argument types for in the code snippet below:

void foo

Type simplification

A typedef may be used to simplify the declaration of a compound type or pointer type. For example,

struct MyStruct ;

This defines the data type. A variable declaration of this type in C also requires the keyword, but it may be omitted in C++:
struct MyStruct a;
A typedef declaration eliminates the requirement of specifying in C. For example, the declaration
typedef struct MyStruct newtype;
is reduced to:
newtype a;
The structure declaration and typedef may also be combined into a single statement:

typedef struct MyStruct newtype;

Or it may be used as follows:

typedef struct newtype;

In C++, in contrast to C, the keywords,, and are optional in variable declarations that are separate from the definitions, as long as there is no ambiguity to another identifier:

struct MyStruct x;
MyStruct y;

As such, can be used wherever can be used. However, the reverse is not true; for instance, the constructor methods for cannot be named.
A notorious example where even C++ needs the keyword is the POSIX stat system call that uses a struct of the same name in its arguments:

int stat

Here both C as well as C++ need the keyword in the parameter definition.

Pointers

The typedef may be used to define a new pointer type.

typedef int *intptr;
intptr ptr;
// Same as:
// int *ptr;

is a new alias with the pointer type. The definition,, defines a variable with the type. So, is a pointer which can point to a variable of type.
Using typedef to define a new pointer type may sometimes lead to confusion. For example:

typedef int *intptr;
// Both 'cliff' and 'allen' are of type int*.
intptr cliff, allen;
// 'cliff2' is of type int*, but 'allen2' is of type int**.
intptr cliff2, *allen2;
// Same as:
// intptr cliff2;
// intptr *allen2;

Above, means defining 2 variables with type for both. This is because a type defined by typedef is a type, not an expansion. In other words,, which is the type, decorates both and. For, the type decorates the and. So, is equivalent to 2 separate definitions, and. means that is a pointer pointing to a memory with type. Shortly, has the type,.

Structures and structure pointers

Typedefs can also simplify definitions or declarations for structure pointer types. Consider this:

struct Node ;

Using typedef, the above code can be rewritten like this:

typedef struct Node Node;
struct Node ;

In C, one can declare multiple variables of the same type in a single statement, even mixing structure with pointer or 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 was indeed a, but a typographical error means that is a. This can lead to subtle syntax errors.

struct Node *startptr, *endptr, *curptr, *prevptr, errptr, *refptr;

By defining the typedef, it is assured that all variables are structure pointer types, or say, that each variable is a pointer type pointing to a structure type.

typedef struct Node* NodePtr;
NodePtr startptr, endptr, curptr, prevptr, errptr, refptr;

Function pointers


int do_math 
int call_a_func) 
int final_result = call_a_func;

The preceding code may be rewritten with typedef specifications:

typedef int ;
int do_math 
int call_a_func 
int final_result = call_a_func;

Here, is the new alias for the type. A is a pointer to a function that returns an integer and takes as arguments a float followed by an integer.
When a function returns a function pointer, it can be even more confusing without typedef. The following is the function prototype of signal from FreeBSD:

void ));

The function declaration above is cryptic as it does not clearly show what the function accepts as arguments, or the type that it returns. A novice programmer may even assume that the function accepts a single as its argument and returns nothing, but in reality it also needs a function pointer and returns another function pointer. It can be written more cleanly:

typedef void ;
sighandler_t signal;

Arrays

A typedef can also be used to simplify the definition of array types. For example,

typedef char arrType;
arrType arr = ;
arrType *pArr;
// Same as:
// char arr = ;
// char ;

Here, is the new alias for the type, which is an array type with 6 elements. For, is a pointer pointing to the memory of the type.

Type casts

A typedef is created using type definition syntax but can be used as if it were created using type cast syntax. For instance, in each line after the first line of:

// `funcptr` is a pointer to a function which takes a `double` and returns an `int`.
typedef int ;
// Valid in C or C++.
funcptr x = NULL;
// Only valid in C++.
funcptr y = funcptr;
funcptr z = static_cast;

is used on the left-hand side to declare a variable and is used on the right-hand side to cast a value. Thus, the typedef can be used by programmers who do not wish to figure out how to convert definition syntax to type cast syntax.
Without the typedef, it is generally not possible to use definition syntax and cast syntax interchangeably. For example:

void *p = NULL;
// This is legal.
int = ) p;
// Left-hand side is not legal.
int y = ) p;
// Right-hand side is not legal.
int = );

Usage in C++

In C++ type names can be complex, and typedef provides a mechanism to assign a simple name to the type.

std::vector> values;
for ; i != values.end; ++i)

and

typedef std::pair value_t;
typedef std::vector values_t;
values_t values;
for ; i != values.end; ++i)

Use with templates

C++03 does not provide templated typedefs. For instance, to have represent for every type one cannot use:

template
typedef std::pair stringpair; // Doesn't work

However, if one is willing to accept in lieu of, then it is possible to achieve the desired result via a typedef within an otherwise unused templated class or struct:

template
class stringpair
// Declare a variable of type `std::pair`.
stringpair::type my_pair_of_string_and_int;

In C++11, templated typedefs are added with the following syntax, which requires the keyword rather than the keyword. 

template 
using stringpair = std::pair;
// Declare a variable of type `std::pair`.
stringpair my_pair_of_string_and_int;

Other languages

In SystemVerilog, typedef behaves exactly the way it does in C and C++.
In many statically typed functional languages, like Haskell, Miranda, OCaml, etc., one can define type synonyms, which are the same as typedefs in C. An example in Haskell:

type PairOfInts =

This example has defined a type synonym as an integer type.
In Seed7 the definition of a constant type is used to introduce a synonym for a type:
const type: myVector is array integer;
In Swift, one uses the keyword to create a typedef:
typealias PairOfInts =
C# contains a feature which is similar to the typedef or the syntax of C++.

using newType = global::System.Runtime.Interop.Marshal;
using otherType = Enums.MyEnumType;
using StringListMap = System.Collections.Generic.Dictionary>;

In D the keyword allows to create type or partial type synonyms.

struct Foo
alias FooInt = Foo!int;
alias Fun = int delegate;

Usage concerns

Kernigan and Ritchie stated two reasons for using a typedef. First, it provides a means to make a program more portable or easier to maintain. Instead of having to change a type in every appearance throughout the program's source files, only a single typedef statement needs to be changed. size_t and ''ptrdiff_t' in are such typedef names. Second, a typedef can make a complex definition or declaration easier to understand.
Some programmers are opposed to the extensive use of typedefs. Most arguments center on the idea that typedefs simply hide the actual data type of a variable. For example, Greg Kroah-Hartman, a Linux kernel hacker and documenter, discourages their use for anything except function prototype declarations. He argues that this practice not only unnecessarily obfuscates code, it can also cause programmers to accidentally misuse large structures thinking them to be simple types.