Typedef

 ( C++ ) 

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.

int current_speed; int high_score;

void congratulate(int your_score) {

   if (your_score > high_score) {
       // ...
   }
     

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(points your_score) {

   if (your_score > high_score) {
       // ...
   }
     

Both sections of code execute identically. However, the use of typedef declarations in the second code block makes 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 (or any other variable not declared as a ) 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() {

   km_per_hour km100 = 100;
   congratulate(km100);
     

struct MyStruct {

   int data1;
   char data2;
     

defines the data type . In C, absent a typedef, the full type name must be used to declare variables of that type:

struct MyStruct a;

A typedef declaration can provide a simpler type name that does not include . For example, with the type declaration

typedef struct MyStruct newtype;

the variable declaration can be reduced to:

newtype a;

The structure declaration and typedef may also be combined into a single declaration:

typedef struct MyStruct {

   int data1;
   char data2;
     

, including when no tag is declared:

typedef struct {

   int data1;
   char data2;
     

In C++, unlike in C, tags of , , , and types (such as the "" above) automatically can be used by themselves as aliases for the full type names, very much as if there were explicit typedefs declaring so at the point of the type declaration:

struct MyStruct x; MyStruct y;

Indeed, for , , and types, C++ calls the tag a class name.

The correspondence between this C++ feature and typedef is very strong, extending to the fact that it is possible to shadow the simple type name in a nested scope by declaring it as the identifier of another kind of entity. In such a case, the C-style full type name (an "elaborated type specifier") can still be used to refer to the class or enum type.

In C++, then, can be used anywhere that can be used, as long as there are no other declarations of these identifiers. The reverse is not true, however, for C++ requires the class name for some purposes, such as the names of constructor methods.

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(const char *filename, struct stat *buf) {

   // ...
     

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

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, .

typedef int *intptr;

const intptr ptr = NULL;

// This is equivalent to: // int *const ptr = NULL; // Constant pointer to an integer.

Since it is a constant pointer, it must be initialized in the declaration.

struct Node {

   int data;
   struct Node *nextptr;
     

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

typedef struct Node Node;

struct Node {

   int data;
   Node *nextptr;
     

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 Struct.

typedef struct Node* NodePtr;

NodePtr startptr, endptr, curptr, prevptr, errptr, refptr;

   return arg2;
     

   int output = call_this(5.5, 7);
     

   return output;
     

   return arg2;
     

   int output = call_this(5.5, 7);
     

   return output;
     

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.
     

   std::pair const & t = *i;
     

   // ...
     

and

typedef std::pair value_t; typedef std::vector values_t;

values_t values;

for (values_t::const_iterator i = values.begin(); i != values.end(); ++i) {

   value_t const & t = *i;
     

   // ...
     

C++11 introduced the possibility to express typedefs with instead of . For example, the above two typedefs could equivalently be written as

using value_t = std::pair; using values_t = std::vector;

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 { private:

   // Prevent instantiation of `stringpair`.
   stringpair();
     

   // Make `stringpair::type` represent `std::pair`.
   typedef std::pair type;
     

// 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. (See template aliases.)

template using stringpair = std::pair;

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

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 = (Int, Int)

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 = (Int, Int)

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(T){} alias FooInt = Foo!int; alias Fun = int delegate(int);