C Tutorial - 21 - Typedef

What is Typedef in C and why we need it

In C, typedef is a keyword that is used to define a new data type based on an existing data type. The purpose of typedef is to simplify the syntax of complex type definitions and make them easier to use and understand.For example, suppose we have a complex data type that represents a pointer to a function that takes two integer arguments and returns a float value:

float (*complex_ptr)(int, int);

This declaration can be difficult to understand and work with, especially if we need to use this type in multiple places throughout our code. To simplify this declaration, we can use typedef to create a new type name that represents this complex data type:

typedef float (*complex_ptr)(int, int);

Now, we can use the complex_ptr type name instead of the full declaration:

complex_ptr my_func_ptr;

This makes the code more readable and easier to understand.In addition to simplifying complex type definitions, typedef can also be used to create aliases for existing data types. For example, we could define a new type name my_int that represents the int data type:

typedef int my_int;

Now, we can use the my_int type name instead of int:

my_int x = 42;

This can be useful in situations where we want to create a new name for an existing data type that better describes its purpose within our code.

 

Typedef in C Example

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

typedef struct Books
{
    char Title[50];
    char Author[50];
    char Topic[100];
    int id_book;
} genericBook;

typedef char CHARACTER;
typedef char LONGLINE[];
typedef int SIZES;


int main()
{

    CHARACTER onlyOne = 'A';
    printf("%c \n", onlyOne);

    LONGLINE headerStart = {"-------------------------- \n"};
    printf("%s \n", headerStart);

    SIZES w = 10;
    SIZES l = 20;
    int area = w * l;

    printf("Rectangle Surface : %d \n", area);

    printf("%s \n", headerStart);

    //struct genericBook Book_1;
    genericBook Book_1;

    strcpy(Book_1.Title, "Relativity T");
    strcpy(Book_1.Author, "Albert E");
    strcpy(Book_1.Topic, "Relativity");
    Book_1.id_book = 4323;

    printf("Book_1 - Title: %s \t\n", Book_1.Title);
    printf("Book_1 - Author: %s \t\n", Book_1.Author);
    printf("Book_1 - Topic: %s \t\n", Book_1.Topic);
    printf("Book_1 - ID: %d \t\n", Book_1.id_book);

    printf("-------------------------- \n");

    return 0;
}

Result:

A
--------------------------

Rectangle Surface : 200
--------------------------

Book_1 - Title: Relativity T
Book_1 - Author: Albert E
Book_1 - Topic: Relativity
Book_1 - ID: 4323
--------------------------

Process returned 0 (0x0)   execution time : 0.016 s
Press any key to continue.

This code demonstrates the usage of the typedef keyword in C.

First, some typedefs are defined:

• CHARACTER is a typedef of char
• LONGLINE is a typedef of char[]
• SIZES is a typedef of int

Then, the code uses these typedefs to declare variables of the corresponding types. For example, onlyOne is declared as a CHARACTER, which is equivalent to char. Similarly, headerStart is declared as a LONGLINE, which is equivalent to char[].

Finally, a typedef is used to define a new type called genericBook. This type is a structure with fields for a book's title, author, topic, and ID number. This typedef allows us to use the name genericBook instead of struct Books when declaring variables of this type.

The code then declares a variable Book_1 of type genericBook and sets its fields using strcpy and an integer value. The values of Book_1's fields are then printed using printf.

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

typedef char CHARACTER;
typedef char LONGLINE[];
typedef int SIZES;

int main()
{

    CHARACTER onlyOne = 'A';
    printf("%c \n", onlyOne);

    CHARACTER secondOne = 'R';
    printf("%c \n", secondOne);

    LONGLINE headerStart = {"----------------------- \n"};
    printf("%s \n", headerStart);

    SIZES w = 10;
    SIZES l = 20;
    int area = w * l;

    printf("Rectangle Surface: %d \n", area);

    printf("%s \n", headerStart);

    return 0;
}

Result:

A
R
-----------------------

Rectangle Surface: 200
-----------------------


Process returned 0 (0x0)   execution time : 0.030 s
Press any key to continue.

This program demonstrates the use of typedef to define new types. The program defines three new types: CHARACTER, LONGLINE, and SIZES.

CHARACTER is defined as a char, LONGLINE is defined as a character array with a fixed length of 100, and SIZES is defined as an int.

In the program, the onlyOne variable is assigned the value 'A', the secondOne variable is assigned the value 'R', and these values are printed to the console using printf.

The headerStart variable is assigned a string value and printed to the console.

The w and l variables are assigned values, and their product is calculated and printed to the console.

Finally, the headerStart variable is printed to the console again.

 

Are Typedefs same as Constants in C

No, typedef and constants are not the same in C. Constants are used to define a value that cannot be modified during program execution, while typedef is used to create an alias for a data type.

For example, #define can be used to define a constant in C, like this:

#define MAX_VALUE 100

This will define MAX_VALUE as a constant with the value of 100. Any attempt to modify the value of MAX_VALUE during program execution will result in a compilation error.On the other hand, typedef is used to define an alias for a data type, like this:

typedef int myInt;

This will define myInt as an alias for the int data type. Any time myInt is used in the program, it will be interpreted as an int data type. However, myInt can still be modified during program execution, as it is not a constant.

 

Are there any rules for naming Typedefs

Yes, just like other variables in C, there are certain rules and conventions that are commonly followed when naming typedefs:

1. Typedef names should be in all uppercase letters to differentiate them from variable names.
2. Names should be meaningful and descriptive to clearly indicate the data type being defined.
3. Typedef names should not conflict with other identifiers in the program, such as function names or variable names.
4. Names should be concise and not too long, while still being descriptive enough to convey the intended meaning.

Following these naming conventions can make the code more readable and maintainable, and can help to avoid naming conflicts and errors.

 

Can we create Typedefs inside and outside main() C function

Yes, we can create typedefs both inside and outside of the main() function in C. typedef is not limited to any specific scope or context, and it can be used to create new type names for any kind of data type, including structures, pointers, arrays, and function pointers. However, it is a good practice to define typedefs at the global scope, outside any function, so that they can be used throughout the program. Defining typedefs inside functions can limit their scope and make them difficult to reuse in other parts of the program.

 

Can we create Typedefs in some other external C file

Yes, we can create typedefs in external C files, and then use them in our current C file by including the header file that declares the typedefs.

For example, suppose we have a file named "mytypedefs.h" that declares some typedefs:

typedef int myint;
typedef char mychar;

We can then include this header file in our current C file and use the typedefs:

#include "mytypedefs.h"
...
myint x = 5;
mychar c = 'a';

Note that we need to make sure that the header file is located in a directory that is in the include path of our C compiler.

 

What are C Header Files

In C programming, header files are used to declare and define various functions, constants, data types, and macros that are needed by a program. Header files contain declarations and definitions that can be shared across multiple source files, allowing for modularity and reusability of code.

Header files typically have a .h extension and contain function prototypes and data type definitions. They are included at the beginning of a C program using the #include preprocessor directive. The C standard library provides a number of header files that contain function and data type declarations for various operations, such as input/output, string manipulation, memory management, and mathematical functions.

Developers can also create their own header files to define custom functions and data types that are specific to their program. Header files help to keep the source code organized and modular, making it easier to understand and maintain.