What is the purpose of type declarations in c?

Answer 1

A type declaration introduces a user-defined type. The new type may be an alias, a structure, a union or an enumeration.

Aliases are typically used to reduce verbosity:

typedef unsigned long long UINT;

Here we can use the UINT alias wherever we'd normally use an unsigned long long. The compiler will treat the UINT type just as it would an unsigned long long. We can also use macros to achieve the same thing however a macro is not type safe.

Data structures allow us to create aggregate data types:

typedef struct Data { int x; double y; char* z; };

Unlike an array where all elements must be of the same type, data structure members may be any type (both built-in and user-defined) and of any length (in bytes). Each member has a name whereas array elements are accessed using zero-based subscripts. The length of a data structure is the sum of its member lengths plus any padding bytes for alignment purposes. For instance, pointers are typically aligned on word boundaries.

In the above example, the full name of the data type is struct Data. Repeating the struct keyword every time we want to use this data type can quickly become tiresome:

struct Data a[100];

struct Data* b;

struct Data c;

Fortunately, we can append an alias to reduce the verbosity:

typedef struct Data { int x; double y; char* z; } data;

Note that the actual type is still struct Data. However, we can now use the alias data in our code:

data a[100];

data* b;

data c;

Unions allow us to optimise memory consumption:

typedef union Stuff { char c; int i; long double d; } stuff;

Unlike a structure where each member is allocated separately, union members are allocated to the same address. The length of a union is equal to the length of the largest member. Unions are useful when we have two or more variables of different types but we only require one of them at any given time. The onus is on the programmer to keep track of which member is the active member.

A common error with new programmers is to use a union as an unsafe type cast. This is particularly bad when the cast is to a pointer type:

typedef union Stuff { int i; int* p; } stuff;

int* cheat (int x) {

stuff s;

s.i = x; // assign the value of x to s.i

return s.p; // "cast" x to a memory address (to int)

}

This function has undefined behaviour. Firstly, the code assumes that an int is the same length as a pointer to int. That may well be the case on some systems but certainly not for all systems. On a 64-bit system an int might be 4 bytes long, but a pointer may well be 8 bytes long. Under those circumstances, the integer value cannot possibly cover the entire address space. Worse, when we assign x to s.i, only the low-order bytes of s.p will be overwritten. The high-order bytes will be whatever value happens to reside in that memory at the time. The returned address could be pointing literally anywhere, but almost certainly not where you intended to be pointing. Even if sizeof (int) and sizeof (int*) are the same length, the code is still unsafe because it would be unreasonable to expect an integer to be allocated to an odd address and there's a 50% chance x is an odd value. Worse, integers are typically aligned on 4-byte boundaries and there's a 75% chance x is not a multiple of 4. And that's before we consider whether the address we return actually belongs to our program. In short, don't use unsafe casts!

An enumeration is simply a group of named constants.

enum e {m1, m2, m3, m4};

By default, members are enumerated in the order they are declared, starting at 0, incrementing by 1 for each subsequent member. However, we can assign any value to any member and restart the enumeration from that point onward. We can even assign the same value to more than one member.

Assuming the default values (m1=0, m2=1, m3=2 and m4=3), we can use the members just as we would any other constant:

void f (e data) {

if (data == m1) {

data = 20;

}

}

In the above example, although the data argument is an e type, we can assign it any valid integral value (20 is not defined by the e type). Typically we would want to restrict values to just those that we defined. For that we need to typedef the enumeration (with an alias):

typedef enum t {m1, m2, m3, m4} e;

void f (e data) {

if (data == m1) {

data = 20; // ERROR: 20 is not an e type

}

}

Enumerations are implicitly int. However, we can also specify any integral type as appropriate:

typedef enum t : char {m1, m2, m3, m4} e;