Typedef in C Programming

Typedef is a keyword in C programming language that is used to give a new name to in built data type or user defined data types. New data type alias can later be used for variable declaration, typecasting etc just like a regular data type name.

For Example
typedef unsigned int POSITIVE_INT;

After above typedef statement POSITIVE_INT can be used as an alias of unsigned int.

POSITIVE_INT employeeCount;

Above declaration statement declares a variable "employeeCount" of type unsigned int using typedef alias POSITIVE_INT.
We can use typedef keyword to assign name to user define data types also like structures and unions.

Use of typedef to give new name to a structure

typedef struct EmployeeDetails{
 char name[50];
 int age;
 int salary;
} Employee;
Now, we can declare variables of EmployeeDetails structure as:
Employee employee_one, employee_two;
We can also give name to a structure after it's declaration
typedef struct EmployeeDetails Employee;

Use of typedef to give name to a Union

typedef union ProductDetails{
 char name[50];
 int price;
 int rating;
} Product;
Now, we can declare variables of ProductDetails union
Product product_one, product_two;
We can also give name to a union after it's declaration
typedef union ProductDetails Product;

C Program to show use of typedef keyword

#include <stdio.h>
#include <string.h>

typedef unsigned long int ULI;

typedef struct EmployeeDetails{
 char name[50];
 int age;
 ULI salary;
} Employee;
int main(){
   Employee employee;
   strcpy(employee.name, "Jack");
   employee.age = 30;
   employee.salary = 10000;
   printf("Employee Name = %s\n", employee.name);
   printf("Employee Age = %d\n", employee.age);
   printf("Employee Salary = %ld\n", employee.salary);

   return 0;
Employee Name = Jack
Employee Age = 30
Employee Salary = 10000

Typedef for User-Defined Data Types

  • Struct Typedef : Typedef is especially useful when working with user-defined data types, such as structures. Consider the following example:
    #include &lt;stdio.h&gt;
    // Define a structure
    struct Point {
        int x;
        int y;
    // Typedef for the structure
    typedef struct Point Point;
    int main() {
        // Declare a variable using the typedef
        Point p1 = {3, 5};
        printf("Point coordinates: (%d, %d)\n", p1.x, p1.y);
        return 0;
    In this example, Point is an alias for the struct Point data type. This makes the code cleaner and allows us to use Point directly when declaring variables.

  • Enum Typedef : typedef is also commonly used with enumerations to create more meaningful names for enumeration types:
    #include <stdio.h>
    // Define an enumeration
    enum Weekdays {
    // Typedef for the enumeration
    typedef enum Weekdays Day;
    int main() {
        // Declare a variable using the typedef
        Day today = WEDNESDAY;
        printf("Today is ");
        switch (today) {
            case MONDAY:    printf("Monday.\n"); break;
            case TUESDAY:   printf("Tuesday.\n"); break;
            case WEDNESDAY: printf("Wednesday.\n"); break;
            case THURSDAY:  printf("Thursday.\n"); break;
            case FRIDAY:    printf("Friday.\n"); break;
            case SATURDAY:  printf("Saturday.\n"); break;
            case SUNDAY:    printf("Sunday.\n"); break;
        return 0;
    Here, Day is an alias for enum Weekdays, making the code more readable and self-explanatory.

  • Function Pointer Typedef : Typedef can also be used on function pointers to describe the kinds of those pointers in a short and clear way. Take a look at this example:
    #include <stdio.h>
    // Define a function pointer type using typedef
    typedef int (*ArithmeticFunction)(int, int);
    // Function to add two numbers
    int add(int a, int b) {
        return a + b;
    // Function to subtract two numbers
    int subtract(int a, int b) {
        return a - b;
    int main() {
        // Declare function pointers using the typedef
        ArithmeticFunction addPtr = add;
        ArithmeticFunction subtractPtr = subtract;
        // Use the function pointers
        printf("Sum: %d\n", addPtr(5, 3));
        printf("Difference: %d\n", subtractPtr(5, 3));
        return 0;
    This code snippet uses the function pointer ArithmeticFunction, which accepts two integer parameters and returns another integer. When defining and utilizing function pointers, this makes the code more understandable.

typedef for Improved Code Maintainability

One of the often-overlooked benefits of typedef is its contribution to code maintainability. When used judiciously, it simplifies modifications to data types throughout the codebase.

Consider a scenario where you need to change the underlying data type of a particular variable. Without typedef, you would need to modify every declaration of that variable type throughout your code. However, with typedef, you only need to update the alias definition.

#include <stdio.h>

typedef int Temperature;  // Alias for temperature data type

int main() {
    Temperature current_temp = 25;

    // ... Some code ...

    // Now, if the temperature data type changes to double
    typedef double NewTemperature;
    NewTemperature updated_temp = 25.5;

    printf("Updated Temperature: %.2f\n", updated_temp);

    return 0;

In this example, changing the temperature data type is a matter of updating the typedef and the relevant variable declarations, enhancing code maintainability.

Benefits of Typedef

You may better understand typedef's importance in developing readable and maintainable code by being aware of its benefits:
  • Readability : typedef makes it possible to create names that are more descriptive, which makes the code easier to understand.

  • Abstraction : It offers a certain amount of abstraction, freeing developers from the minutiae of underlying data types so they may concentrate on the high-level design.

  • Code Maintenance : Using typedef facilitates more efficient, centralized code updates when data types need to be modified.

  • Portability : Code portability can be improved via typedef, which offers a standard interface that facilitates code adaptation to many platforms and compilers.

Best Practices and Considerations for Typedef in C

Although typedef is a useful tool, it must be used carefully to avoid any potential problems:
  • Meaningful Names : To improve code readability, give the new data types produced using typedef meaningful names.

  • Consistency : To preserve a consistent and dependable coding style, utilize typedef consistently across the codebase.

  • Avoid Overuse : Typedef should not be used extensively for simple scenarios as this might add needless complexity.

  • Documentation : To assist other developers in understanding the function and use of the aliased types, document the typedefs in your code.


In summary, the typedef keyword in C serves as a beneficial instrument in facilitating code maintenance, enhancing abstraction, and improving code readability. Typedef facilitates the development of code that is lucid and articulate by assigning valid names to structures, data types, function pointers, and enumerations. Gaining comprehension of the syntax, illustrations, and optimal methodologies expounded in this tutorial will grant you the ability to effectively utilize typedef in your C programming endeavors. Incorporating typedef into your coding practices as you further refine your programming abilities will significantly contribute to the creation of software that is lucid, maintainable, and efficient.

As you incorporate typedef into your coding practices, consider its application in structures, pointers, and function pointers. Strive for meaningful and descriptive aliases to make your code more self-explanatory. Whether you're aiming for improved readability or streamlined code maintenance, typedef empowers you to craft C programs that are not only efficient but also a joy to work with.