X

### Structures

• A structure is a collection of one or more variables, possibly of different types, grouped together under a single name for convenient handling.

• Example : Let us create a few structures suitable for graphics. The basic object is a point, which we will assume has an x coordinate and a y coordinate, both integers.

• ```struct point {
int x;
int y;
};
```

• The keyword struct introduces a structure declaration, which is a list of declarations enclosed in braces. An optional name called a structure tag may follow the word struct.

• The variables named in a structure are called members. A structure member or tag and an ordinary (i.e., non-member) variable can have the same name without conflict, since they can always be distinguished by context.

• A struct declaration defines a type. The right brace that terminates the list of members may be followed by a list of variables, just as for any basic type. Example : struct { ... } x, y, z;

• A structure declaration that is not followed by a list of variables reserves no storage; it merely describes a template or shape of a structure. If the declaration is tagged, however, the tag can be used later in definitions of instances of the structure. For example, given the declaration of point above, struct point pt; defines a variable pt which is a structure of type struct point.

• A member of a particular structure is referred to in an expression by a construction of the form structure-name.member The structure member operator ``.'' connects the structure name and the member name. Example : printf("%d,%d", pt.x, pt.y);

Q. Demonstrate Nested Structures

• ```  struct rect {
struct point pt1;
struct point pt2;
};```

• ```The rect structure contains two point structures. If we declare screen as
struct rect screen;
then
screen.pt1.x```

### Structures and Functions

• The only legal operations on a structure are copying it or assigning to it as a unit, taking its address with &, and accessing its members.

• Structures may not be compared.

• ```   /* makepoint:  make a point from x and y components */
struct point makepoint(int x, int y)
{
struct point temp;
temp.x = x;
temp.y = y;
return temp;
}
```

• The above can now be used to initialize any structure dynamically, or to provide structure arguments to a function:

• ```   struct rect screen;
struct point middle;
struct point makepoint(int, int);
screen.pt1 = makepoint(0,0);
screen.pt2 = makepoint(XMAX, YMAX);
middle = makepoint((screen.pt1.x + screen.pt2.x)/2,
(screen.pt1.y + screen.pt2.y)/2);
```

### Arrays of Structures

• Consider writing a program to count the occurrences of each C keyword. We need an array of character strings to hold the names, and an array of integers for the counts. One possibility is to use two parallel arrays, keyword and keycount. char *keyword[NKEYS]; int keycount[NKEYS];

• Each keyword is a pair: char *word; int cout;

• ```The structure declaration
struct key {
char *word;
int count;
} keytab[NKEYS];
declares a structure type key, defines an array keytab of structures of this type, and sets aside
storage for them.
```

• ```Each element of the array is a structure. This could also be written
struct key {
char *word;
int count;
};
struct key keytab[NKEYS];
```

### Typedef

• C provides a facility called typedef for creating new data type names. For example, the declaration typedef int Length;

• The type Length can be used in declarations, casts, etc., in exactly the same ways that the int type can be:

• ```   Length len, maxlen;
Length *lengths[];```

### Unions

• A union is a variable that may hold (at different times) objects of different types and sizes, with the compiler keeping track of size and alignment requirements.

• The purpose of a union - a single variable that can legitimately hold any of one of several types.

• ```The syntax is based on structures:
union u_tag {
int ival;
float fval;
char *sval;
} u;
```

• ```Syntactically, members of a union are accessed as
union-name.member
or
union-pointer->member
just as for structures. ```

• Unions may occur within structures and arrays, and vice versa. The notation for accessing a member of a union in a structure (or vice versa) is identical to that for nested structures.

• ```struct {
char *name;
int flags;
int utype;
union {
int ival;
float fval;
char *sval;
} u;
} symtab[NSYM];```

 Previous Next