1. 1 Structures & Unions

2. 2 User-Defined Types C provides facilities to define one’s own types. These may be a composite of basic types ( int, double, etc) and other user-defined types. The most common user-defined type is a structure, defined by the keyword struct. Another, less common, form of user-defined type is a union, which will be discussed in the next lecture.

3. 3 Structures A structure is a collection of one or more variables, possibly of different types, grouped together under a single name for convenient handling (K&R page 127). Structures are user-defined aggregate types. They assist program organisation by –Grouping logically related data, and giving this set of variables a higher- level name and more abstract representation. –Enabling related variables to be manipulated as a single unit rather than as separate entities. –Reducing the number of parameters that need to be passed between functions. –Providing another means to return multiple values from a function.

4. 4 Structure Syntax A structure is defined by the keyword struct followed by a set of variables enclosed in braces. Consider the following structure to represent 2-D points. struct Point { int x; int y; }; The variables x and y are called members of the structure type Point. Style note: Structures are given names with Capital first letters, by convention. Distinguish them from variables and functions (lowercase first letter), and symbolic constants (all uppercase).

5. 5 Declaring Structure Variables There are several equivalent ways to define variables of a particular structure type. 1.Declare them at the structure definition. struct Point { int x; int y; } p1, p2, p3; /* Define 3 variables */ If these 3 variables were the only definitions of type Point, and the type is not used again, we may well have written struct { int x; int y; } p1, p2, p3; /* Define 3 variables */ 2.Define the variables at some point after the structure definition. struct Point p1, p2, p3; /* Define 3 variables */

6. 6 Initialising Structure Variables A structure may be initialised when it is defined using brace notation. struct Point topleft = {320, 0}; The order of values in the initialiser list matches the order of declarations in the structure.

7. 7 Accessing Members Members of a structure type may be accessed via the “. ” member operator. struct Point topleft; topleft.x = 320; topleft.y = 0; struct Point delta = { pt1.x - pt2.x, pt1.y - pt2.y }; double distance = sqrt((double)delta.x * delta.x + (double)delta.y * delta.y);

8. 8 Nested Structures Structures may be defined inside other structures. struct Rectangle { struct Point topleft; struct Point bottomright; }; To access lower-level members, need to use member operator multiple times. struct Rectangle rect; rect.topleft.x = 50;

9. 9 Operations on Structures Operations permitted on structure types is a subset of those permitted on basic types. Structures may be copied and assigned, but not compared. struct Point p1 = { 0, 0 }; struct Point p2; p2 = p1; /* Valid. */ if (p1 == p2) /* Invalid.*/ printf("Points are equal\n"); if (p1.x == p2.x && p1.y == p2.y) /* Valid. */ printf("Points are equal\n");

10. 10 Operations on Structures Structures may be passed to functions and returned from functions. (This is a consequence of being copyable.) struct Point point_difference(struct Point p1, struct Point p2) /* Return the delta (dy, dy) of p2 with respect to p1. */ { p2.x -= p1.x; p2.y -= p1y; return p2; } As for other variables, structures are passed-by-value. So, the second argument in the calling function will not be affected by the changes to p2.

11. 11 Pass by Reference Pass by value may be very inefficient if the structure is large (ie, has many members). Passing a pointer to a structure is generally much more efficient than making a copy of the structure itself. Defining pointer types is the same as for variables of primitive types. struct Point pt = { 50, 50 }; struct Point *pp; pp = &pt; (*pp).x = 100; /* pt.x is now 100. */

12. 12 Pointers to Structures Notice the parentheses around the dereferenced pointer. (*pp).x = 100; This is necessary to enforce correct precedence. An alternative notation permits simpler pointer access to structure members. (*pp).x = 100; pp->x = 100; /* equivalent */ Another example, struct Rectangle rect, *pr = ▭ rect.topleft.x = 50; /* equivalent operations */ (*pr).topleft.x = 50; pr->topleft.x = 50;

13. 13 Arrays of Structures The definition of arrays of structure types is virtually identical to arrays of primitive types. struct Point pa[10]; Structure arrays can be initialised with an initialiser list enclosed in braces (and the size is determined by the compiler if unspecified). struct Point pa[] = { {0, 0}, {0, 240}, {320, 240}, {320, 0} };

14. 14 Structure Arrays The size of a structure in bytes may be found via the sizeof operator. The usual C idiom may be used to compute the number of elements in an array of structures. struct Point pa[] = { {0, 0}, {0, 240}, {320, 240}, {320, 0} }; struct Point *pp = pa; for (; pp != pa + sizeof(pa) / sizeof(pa[0]); ++pp) printf("%d %d\n", pp->x, pp->y);

15. 15 Structures and Pointer Arithmetic As with primitive types, the compiler knows the size of a structure and, given a pointer of a structure type will compute the appropriate address offsets automatically. Important. The size of a structure need not equal the sum of its constituent parts. Most real machines have alignment restrictions for certain types (e.g., integers must be located at even addresses). The compiler will pad a structure with unnamed “holes” to ensure each member is properly aligned. Eg, the following structure might not have size 5-bytes, but 6 or 8-bytes. struct MyStruct { char c; int i; }; The sizeof operator returns the correct size.

16. 16 Self-Referential Structures A structure may not contain an object of its own type. struct Node { int item; struct Node n; /* Invalid */ }; In general, a structure may not contain an object of an incomplete type. However, a structure may contain a pointer to an incomplete type. struct Node { int item; struct Node *pn; /* Valid */ };

17. 17 Self-Referential Structures The ability to refer to (ie, point to) an incomplete type, including itself, is an important property for constructing a variety of data-structures. For example: linked-lists, binary trees, graphs, hash tables, and more.

18. 18 Example: A Linked List Linked lists come in two basic varieties: singly linked and doubly linked. We describe here a simple version of a singly linked list. List consists of a set of nodes, where each node contains an item and a pointer to another list node. struct List { int item; struct List *next; }; (Here we have chosen an int as the contained item. Any other type(s) may be used.)

19. 19 Unions Unions look similar to structures. They have identical declaration syntax and member access, but they serve a very different purpose. union Utype { int ival; float fval; char *sval; }; union Utype x, y, z; Accessing members of a union is via “. ” member operator or, for pointers to unions, the -> operator.

20. 20 Unions A union holds the value of one-variable at a time. The compiler allocates storage for the biggest member of the union. The type retrieved from the union must be the type most recently stored. Otherwise, the result is implementation dependent. union Utype x; x.fval = 56.4; /* x holds type float. */ printf("%f\n", x.fval); /* OK. */ printf("%d\n", x.ival); /* Implementation dependent. */

21. 21 Unions Unions are used to store one of a set of different types. Commonly used to implement a “variant” array. (This is a form of generic programming.) There are other uses also, but they are quite advanced (e.g., concern the alignment properties of unions).