1. Structure

2. User Defined Data Types (typedef)
Winter 2005
Engineering H192
User Defined Data Types (typedef)
The C language provides a facility called typedef for creating synonyms for previously defined data type names.
For example, the declaration:
typedef int Length;
makes the name Length a synonym (or alias) for the data type int.
The data type name Length can now be used in declarations in exactly the same way that the data type int can be used:
Length a, b, len ;
Length numbers[10] ;
typedef char String[50];
typedef int Array[10];
String name;
Array ages;
Instructor:
Typedef acts as a macro for data types. In the given example, whenever the alias Length appears in code, the compiler automatically knows to replace this with int, thus effectively giving length the type definition of int.
Lecture 23

3. Structures (struct)
Structures—sometimes referred to as aggregates—are collections of related variables under one name
Structures may contain variables of many different data types—in contrast to arrays that contain only elements of the same data type
Structures are commonly used to define records
Pointers and structures facilitate the formation of more complex data structures such as linked lists, queues, stacks and trees
Structures are derived data types—they are constructed using objects of other types

4. Declaring Structures (struct)
The name "employee" is called a structure tag
Variables declared within the braces of the structure definition are the structure’s members
struct employee
{ char firstName[ 20 ]; char lastName[ 20 ]; int age; char gender; double hourlySalary; };
struct employee Ali, emp[10];
struct employee
{ char firstName[ 20 ]; char lastName[ 20 ]; int age; char gender; double hourlySalary;
} Ali, Sara, empDTS[20];
struct employee Reza, *emp;
struct
{ char firstName[ 20 ]; char lastName[ 20 ]; int age; char gender; double hourlySalary;
} Ali;

5. Declaring Structures (struct)
Often, typedef is used in combination with struct to declare a synonym (or an alias) for a structure:
typedef struct
{ char firstName[ 20 ]; char lastName[ 20 ]; int age; char gender; double hourlySalary;
} employee; /* The "alias"
employee Ali; /* Create a struct variable */
struct employee
{ char firstName[ 20 ]; char lastName[ 20 ]; int age; char gender; double hourlySalary;
} Ali, Sara, empDTS[20];
struct employee Reza, *emp;

6. Declaring Structures (struct)
Members of the same structure type must have unique names, but two different structure types may contain members of the same name without conflict
Each structure definition must end with a semicolon
struct employee
{ char Name[ 20 ]; char Name[ 20 ]; // Error!!! int age; char gender; double hourlySalary;
} Ali, Sara, empDTS[20];
struct employee Reza, *emp;
struct Student
{ char Name[ 20 ]; // OK int age; char gender; };
struct Student Ce40153[80];

7. Declaring Structures (struct)
A structure cannot contain an instance of itself
For example, a variable of type struct employee cannot be declared in the definition for struct employee A pointer to struct employee, however, may be included
A structure containing a member that is a pointer to the same structure type is referred to as a self-referential structure
struct employee2 { // … double hourlySalary; struct employee2 person; /* ERROR */ struct employee2 *ePtr; /* pointer */ };

8. Declaring Structures (struct)
The structure tag name is optional
If a structure definition does not contain a structure tag name, variables of the structure type may be declared only in the structure definition—not in a separate declaration
struct
{ char firstName[ 20 ]; char lastName[ 20 ]; int age; char gender; double hourlySalary;
} Ali;

9. Structure’s sizeof
struct employee {
char firstName[ 20 ];
char lastName[ 20 ];
int age;
char gender;
double hourlySalary; };
struct employee Ali, emp[10];
printf("%d", sizeof(Ali));
printf("%d", sizeof(emp));
printf("%d", sizeof(struct employee));
Structure definitions do not reserve any space in memory; rather, each definition creates a new data type that is used to define variables
sizeof(struct …) =
sum of sizeof(members) +
alignment padding
(Processor- and compiler- specific)

10. alignment padding
 it's much, much easier on the processor if the compiler arranges it like this:
struct {
char a[3];
short int b;
long int c;
char d[3]; };
most compilers will “pad” the structure (as if with extra, invisible fields) like this:

11. Accessing Struct Members
Individual members of a struct variable may be accessed using the structure member operator (the dot, "."):
  myEmp.firstName ;
employee. firstName; // Error
Or , if a pointer to the struct has been declared and initialized
  employee *emp = &myEmp ;
by using the structure pointer operator :
  emp -> firstName; // arrow operator
which could also be written as:
  (* emp).firstName;
struct employee {
char firstName[ 20 ];
// …
} myEmp;

12. An Example - Initialization
struct identity {
char FirstName[30];
char LastName[30];
unsigned age;
struct personal person; };
//Create a struct but don’t reserve space
struct personal {
long id; // student ID
float gpa; // grade point average };
struct identity js = {"Joe", "Smith", 25}, *ptr = &js ;
js.person.id = ;
js.person.gpa = 3.4 ;
printf ("%s %s %d %ld %f\n", js.FirstName, js.LastName, js.age, js.person.id, js.person.gpa) ;
printf ("%s %s %d %ld %f\n", ptr->FirstName, ptr->LastName,ptr->age, ptr->person.id, ptr->person.gpa) ;
js.personal.id Error
js = {"Joe", "Smith", 25, 9, 10}
strcpy(js.FirstName, "Joe");
struct identity js = {"Joe", "Smith", 25,{123,3.4}}

13. An Example - Assignment
//Create a struct but don’t reserve space
struct personal {
long id; // student ID
float gpa; // grade point average };
struct identity {
char FirstName[30];
char LastName[30];
unsigned age;
struct personal person; };
struct identity js = {"Joe", "Smith", 25}, oj ,*ptr;
js.person.id = ;
js.person.gpa = 3.4 ;
oj = js;
ptr=&oj;
printf ("%s %s %d %ld %f\n", oj.FirstName, oj.LastName, oj.age, js.person.id, oj.person.gpa) ;
printf ("%s %s %d %ld %f\n", ptr->FirstName, ptr->LastName,ptr->age, ptr->person.id, ptr->person.gpa) ;

14. Linked Lists (example 1)
typedef struct LinkedList{
int X;
struct LinkedList * nextnode;
}linkedlist;
linkedlist node1={10,0};
printf("Linked list with 1 node contain: %d\n",node1.X);
linkedlist node2={20,0};
node1.nextnode=&node2;
linkedlist node3={30,0};
node2.nextnode=&node3;
printf("Show the linked list values:\n");
linkedlist* ptr=&node1;
printf("%d\n",ptr->X);
while(ptr->nextnode) {
ptr=ptr->nextnode; }

15. Linked Lists (example2)
typedef struct LinkedList{
int X;
struct LinkedList * nextnode;
}linkedlist;
linkedlist* node1;
node1=(linkedlist*) malloc(sizeof(linkedlist));
node1->X=10;
node1->nextnode=0;
linkedlist* ptr=node1,*lastnode;
int i;
//create linke list!
for(i=20;i<100;i+=10) {
lastnode=(linkedlist*) malloc(sizeof(linkedlist));
lastnode->X=i;
lastnode->nextnode=0;
ptr->nextnode=lastnode;
ptr=ptr->nextnode; }

16. //show linked list value ptr=node1;
printf("fill node %d\n",ptr->X);
while(ptr->nextnode) {
ptr=ptr->nextnode; }
//free linked list
ptr=node1;
linkedlist *ptr2=node1->nextnode;
ptr->nextnode=0;
printf("free %d\n",ptr->X);
free(ptr);
while(ptr2) {
ptr=ptr2;
ptr2=ptr2->nextnode; }

17. Arrays of Structures //Create a struct but don’t reserve space
struct identity sharifC40153[80] = {“Omid", "Jafarinezhad", 14, , 20,
"Samad", "Shekarestani", 90, , 20} ;
strcpy(sharifC40153[2].FirstName, "Khaje Nezam");
strcpy(sharifC40153[2].LastName, "Shekarestani");
sharifC40153[2]. age = 100;
sharifC40153[2]. person.id = ;
sharifC40153[2]. person. gpa = 20;
Arrays of Structures
//Create a struct but don’t reserve space
struct personal {
long id; // student ID
float gpa; // grade point average };
struct identity {
char FirstName[30];
char LastName[30];
unsigned age;
struct personal person;
} students[4];
person
age
LastName
FirstName
gpa id 20 14
Jafarinezhad
omid
students[0] 90
Shekarestani
Samad
Students[1]
100
Khaje Nezam
students[2]
students[3]

18. An Example #define NFRIENDS 10 struct Date { unsigned year;
unsigned month;
unsigned day; };
struct Friend
char FirstName[30];
char LastName[30];
struct Date Birthday;
bool check_birthday(struct Date today, struct Date myFriend) {
if ((today.month == myFriend.month) &&
(today.day == myFriend.day))
return (true);
return (false); }
int main()
struct Friend friends[NFRIENDS];
struct Date today = {2012, 3, 11};
// ...
for (i = 0; i < NFRIENDS; i++)
if(check_birthday(today, friends[i].Birthday))
printf ("%s %s\n", friends[i].FirstName, oj.LastName) ;
} // …
typedef struct {
unsigned year;
unsigned month;
unsigned day;
} Date;
bool check_birthday(Date today, Date myFriend)
//… }

19. Pointers to Structures
Date create_date1(int month,
int day,
int year) {
Date d;
d.month = month;
d.day = day;
d.year = year;
return (d); }
void create_date2(Date *d,
int month,
int day,
int year) {
d->month = month;
d->day = day;
d->year = year; }
Pass-by-reference
Date today;
today = create_date1(9, 4, 2008);
create_date2(&today, 9, 4, 2008);
Copies date

20. Pointers to Structures
void create_date2(Date *d,
int month,
int day,
int year) {
d->month = month;
d->day = day;
d->year = year; }
void foo(void)
Date today;
create_date2(&today, 9, 4, 2008);
month: 9
day: 4
year: 2008
0x30A0
0x30A4
0x30A8
d: 0x1000
0x3098
today.month:
today.day:
today.year:
0x1000
0x1004
0x1008
2008 4 9

21. Pointers to Structures
Date * create_date3(int month,
int day,
int year) {
Date *d;
d->month = month;
d->day = day;
d->year = year;
return (d); }
What is d pointing to?!?!

22. Pointers to Structures
void changeByValue(Date date) {
date.day ++; }
void changeByRef(Date *date)
date->day++;
void printDate(const Date date)
printf("today(d/m/y) is : \n");
printf("%d/%d/%d\n", date.day, date.month, date.year);
Date today = {2012, 3, 11};
printDate(today);
changeByValue(today);
changeByRef(&today);
today(d/m/y) is :
11/3/2012
12/3/2012

23. Compression of Structures
Structures may not be compared using operators == and !=
struct a {
int a; // OK
int b; };
struct a b, c;
b.a = 10;
b.b = 30;
c = b;
if(c == b) // Error

24. Winter 2005
Engineering H192
Enumeration
Enumeration is a user-defined data type. It is defined using the keyword enum and the syntax is:
enum tag_name {name_0, …, name_n} ;
The tag_name is not used directly. The names in the braces are symbolic constants that take on integer values from zero through n. As an example, the statement:
enum colors { red, yellow, green } ;
creates three constants. red is assigned the value 0, yellow is assigned 1 and green is assigned 2
Instructor:
Enumeration is essentially a method of creating a numbered list. It allows the user to assign names to numbers which can then be used as indices in an array. An example is given on the next two slides.
Lecture 23

25. Enumeration
Values in an enum start with 0, unless specified otherwise, and are incremented by 1
The identifiers in an enumeration must be unique
The value of each enumeration constant of an enumeration can be set explicitly in the definition by assigning a value to the identifier
Multiple members of an enumeration can have the same constant value
Assigning a value to an enumeration constant after it has been defined is a syntax error
Use only uppercase letters enumeration constant names. This makes these constants stand out in a program and reminds you that enumeration constants are not variables

26. Winter 2005
Engineering H192
An Example
/* This program uses enumerated data types to access the elements of an array */
#include <stdio.h>
int main( ) {
int March[5][7]={{0,0,1,2,3,4,5},
{6,7,8,9,10,11,12},
{13,14,15,16,17,18,19},
{20,21,22,23,24,25,26},
{27,28,29,30,31,0,0}};
enum days {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};
enum week {week_one, week_two, week_three, week_four, week_five};
printf ("Monday the third week of March is March %d\n",
March [week_three] [Monday] ); }
Instructor:
Another two-dimensional calendar array is created similar to previous array examples, and then the days of the week are enumerated.
Lecture 23

27. An Example /* enumeration constants represent months of the year */
enum months {JAN = 1, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC };
enum months month;
/* initialize array of pointers */
const char *monthName[] = { "", "January", "February", "March",
"April", "May", "June", "July", "August", "September", "October", “November", "December"};
/* loop through months */
for (month = JAN; month <= DEC; month++ ) {
printf( "%2d%11s\n", month, monthName[month] ); }

28. Unions
A union is a derived data type—like a structure—with members that share the same storage space
For different situations in a program, some variables may not be relevant, but other variables are—so a union shares the space instead of wasting storage on variables that are not being used
The members of a union can be of any data type
The number of bytes used to store a union must be at least enough to hold the largest member
Only one member, and thus one data type, can be referenced at a time

29. Unions representationc
union myDataUnion {
int i;
char c;
float f;
} u1, u2;
union myDataUnion u3;
u1.i = 4;
u1.c = ’a’;
u2.i = 0xDEADBEEF; i f

30. Unions
The operations that can be performed on a union are the following:
assigning a union to another union of the same type
taking the address (&) of a union variable
accessing union members using the structure member operator and the structure pointer operator
Unions may not be compared using operators == and != for the same reasons that structures cannot be compared

31. Unions
In a declaration, a union may be initialized with a value of the same type as the first union member
union a {
int a; // OK
char b[4]; };
union a b = {10};
printf("%d", b.a);

32. Unions ? A union value doesn’t "know" which case it contains
How should your program keep track whether elt1, elt2 hold an int or a char? ?
union AnElt {
int i;
char c;
} elt1, elt2;
elt1.i = 4;
elt2.c = ’a’;
elt2.i = 0xDEADBEEF;
if (elt1 currently has a char) …
Basic answer: Another variable holds that info

33. Tagged Unions Tag every value with its case
enum Union_Tag {IS_INT, IS_CHAR};
struct TaggedUnion {
enum Union_Tag tag;
union {
int i;
char c;
} data; };

34. Bit-field Structures
C enables you to specify the number of bits in which an unsigned or int member of a structure or union is stored
This is referred to as a bit field
Bit fields enable better memory utilization by storing data in the minimum number of bits required
Bit field members must be declared as int or unsigned
A bit field is declared by following an unsigned or int member name with a colon (:) and an integer constant representing the width of the field (i.e., the number of bits in which the member is stored)

35. Bit-field Structures
Notice that bit field members of structures are accessed exactly as any other structure member
Padded to be an integral number of words
Placement is compiler-specific
struct Flags {
int f1:3;
unsigned int f2:1;
unsigned int f3:2;
} foo;
foo.f1 = -2;
foo.f2 = 1;
foo.f3 = 2; 1 … f1 f2 f3
…8 bit …

36. Unnamed Bit-field
struct example {
unsigned a : 13;
unsigned : 19;
unsigned b : 4; };
uses an unnamed 19-bit field as padding—nothing can be stored in those 19 bits
An unnamed bit field with a zero width is used to align the next bit field on a new storage-unit boundary
For example, the structure definition
struct example { unsigned a : 13; unsigned : 0; unsigned b : 4;
uses an unnamed 0-bit field to skip the remaining bits (as many as there are) of the storage unit in which a is stored and to align b on the next storage-unit boundary

37. An Example - disk drive controller
Frequently device controllers (e.g. disk drives) and the operating system need to communicate at a low level. Device controllers contain several registers which may be packed together in one integer

38. An Example - disk drive controller
struct DISK_REGISTER {
unsigned ready:1;
unsigned error_occured:1;
unsigned disk_spinning:1;
unsigned write_protect:1;
unsigned head_loaded:1;
unsigned error_code:8;
unsigned track:9;
unsigned sector:5;
unsigned command:5; };
struct DISK_REGISTER *disk_reg = (struct DISK_REGISTER *) DISK_REGISTER_MEMORY;
/* Define sector and track to start read */
disk_reg->sector = new_sector;
disk_reg->track = new_track;
disk_reg->command = READ;
/* wait until operation done, ready will be true */
while ( ! disk_reg->ready ) ;
/* check for errors */
if (disk_reg->error_occured)
{ /* interrogate disk_reg->error_code for error type */
switch (disk_reg->error_code)
...... }

39. Notes of caution Bit-field manipulations are machine dependent
Attempting to access individual bits of a bit field as if they were elements of an array is a syntax error. Bit fields are not "arrays of bits"
Attempting to take the address of a bit field (the & operator may not be used with bit fields because they do not have addresses)
Although bit fields save space, using them can cause the compiler to generate slower-executing machine-language code. This occurs because it takes extra machine language operations to access only portions of an addressable storage unit. This is one of many examples of the kinds of space–time trade-offs that occur in computer science