Prof. Carl Schultheiss MS, PE. CLASS NOTES Lecture 12

Transcription

1 Prof. Carl Schultheiss MS, PE CLASS NOTES Lecture 12

2 In addition to the basic data types C supports user-defined data types. Userdefined data types allow the development of programs using data types that are suited for the application. Many applications work with collections of related items of information, an array is an example, however the elements of an array must be of the same data type. C provides a data type called a structure that allows the programmer to store a collection of related data items of different types under one name. The individual items that comprise the structure can be any valid C data type including arrays and other structures.

3 The individual items that comprise a structure can be any of the basic data types, char, int, float, double, arrays, or other structures. To create a structure: a) Define the structure. b) Declare variables of that type. The structure definition specifies a template for the structure and tells the compiler what the various elements are that make up the structure. The structure declaration creates structure variables of the type defined in the structure definition. The structure name is called the structure tag. The data items that comprise the structure are called members.

4 An example of the syntax for defining a structure is: struct rectangle { float x1; /* x coordinate of top left corner */ float y1; /* y coordinate of top left corner */ float x2; /* x coordinate of bottom right corner */ float y2; /* y coordinate of bottom right corner */ int color; /* line color */ int id_number; /* identification number */ int level; /* display level */ };

5 The compiler does not allocate storage or create structure variables when the structure definition is processed. The structure definition can be placed inside a function, this creates a local structure that can only be used inside that function. It can also be defined outside of any function, a global structure available to any functions following it.

6

7 To create structure variables, we have to declare variables of the type defined in the structure definition. The structure definition must preceed the structure declaration. Structure declaration example: struct rectangle old_rect, curr_rect, new_rect;

8 struct Student { char name[41]; char address[41]; char ID_Num[11]; int dept_code; int major; }; Create a variables of type Student : struct Student MyStudent; Create an array of type Student : struct Student MyStudents[100];

9

10

11

12 External and static structure variables can be initialized when they are declared. The place the variables are defined, not the template location, determines whether it is external. The structure variable is followed by an assignment symbol (=) and a list of values in braces. static struct rectangle new_rect = {0.0, 5.0, 10.0, 50.0, 5, 1, 3}; The values are assigned to the individual members in the order the members and values appear.

13 Members of a static or extern structure are assigned the value zero unless explicitly initialized. If the number of initialized values is less than the number of members the rest of the members are assigned zeros. Automatic structure variables must be initialized using the explicit assignment statements. static struct rectangle rect[3] = { {0.0, 0.0, 10.0, 1.2, 5, 1, 1}, /* rect[0] */ {1.0, 1.0, 20.0, 2.4, 5, 1, 1}, /* rect[1] */ }; This creates an array rect[] of type rectangle. There are three elements in the array, rect[0], rect[1], rect[2]. rect[0] and rect[1] are initialized as shown, rect[2] is automatically all zeros.

14 The syntax for accessing the members of a structure is: structure_variable.member_name The period (.) is called the structure member of operator. An example: new_rect.x1 = 2.5; The members of structures can be used in arithmetic expressions. width = new_rect.x2 - new_rect.x1;

15 The following operations can be performed on structures: a) Initialize static and external structures. b) Access one of the members of a structure. c) Assign a structure, as a whole, to another structure. The assignment operator is used to assign the value of one structure to another structure of the same type. d) Use the sizeof operator to determine the size of a structure in bytes. The sizeof operator applied to a structure returns the total number of bytes of storage taken by the structure. e) Use the address-of operator (&) to find the address of a structure. f) Pass a structure to a function. g) Return a structure from a function.

16 C allows one structure to be included within another structure. The structure embedded within another structure is called a nested structure. The definition of the nested structure must appear before its use in the other structure. It can be more convienient to group related members of a structure into nested structures rather than have one structure with a large number of memebers.

17 struct point { float x; /* x coordinate of point */ float y; /* y coordinate of point */ }; struct rect { struct point top_left; /* top left corner of rectangle */ struct point bot_right; /* bottom right corner of rectangle */ float area; /* area of rectangle */ };

18 To access a member of a nested structure use the member of operator (.) twice. An example: struct rect rect1 /* creates a structure called rect1 */ rect1.top_left.x; /* accesses x coordinate of top left point in rect1 */ rect1.top_left.y; /* accesses y coordinate of top left point in rect1 */ An example of assignment: rect1.top_left.x = 10.0; rect1.top_left.y = 20.0;

19 C supports pointers to structures and has a special pointer operator for accessing members of structures. Pointers to structures are easier to manipulate than structures themselves. The declaration syntax is: struct rect *ptr_rect1; this allocates the pointer, to assign a value to the pointer the address-of operator (&) is used: struct rect rect1, *ptr_rect1; this creates a structure variable called rect1 and a pointer to a structure of type rect. Then the pointer is initialized with: ptr_rect1 = &rect1;

20 The indirection operator can be used to access a member of a structure using a pointer. Thus (*ptr_rect1).x1 returns the value of the member x1 of the structure rect1. The parentheses are necessary since the member of operator (.) has higher precedence than the indirection operator (*). Without the parentheses this would be interpreted as *(ptr_rect1.x1)

21 It is very common to dereference a pointer to a structure and then access a member of that structure, therefore C provides an operator called the pointer operator. The following syntax is used to obtain the value of a particular member of a structure: ptr_to_structure -> structure_member An example: xcoor = ptr_rect1 -> x1 returns the value of the x1 member of the structure rect1 and places it in variable xcoor.

22 There are several ways to pass the information in a structure to a function: a) Pass the individual members of a structure, like variables are passed. b) Pass the entire structure to the function. c) Pass the address of the structure variable using a pointer to the structure.

23 struct circle { float xc; /* x coordinate of center */ float yc; /* y coordinate of center */ float radius; /* radius of circle */ int color; /* line color */ } circ1; /* Define a function to compute the area */ #define PI float area(float rad) { return(rad * rad * PI); }

24 /* Pass the radius member of structure circle to the function area() */ result = area(circ1.radius); Here a local copy of the structure variable circ1.radius is passed to the function. Changes made to the variable are local only and circ1.radius is not changed. If the value of circ1.radius were to be changed, a call by reference would be necessary using the address of the variable.

25 /* A function expecting an address */ void modify_radius(float *rad) { *rad = 10.0; } /* Call the function with an address*/ modify_radius(&circ1.radius);

26 The entire structure can be passed to a function as an argument. The structure is passed by value. The function works on a local copy of the structure and can not change the orignal structure.

27 /* a structure variable is defined */ struct rect rect1; /* The function header for the function that recieves the structure */ float area(struct rect r) { width = r.x2 - r.x1; height = r.y2 - r.y1; return(width*height); } /* The call to the function */ result = area(rect1);

28 Functions can also return structures. The return type of the function must be a structure of the appropriate type. The calling function must also declare a structure of the appropriate type to receive the structure. An example: /* A function header that returns a structure */ struct rect get_rect(void) /* The calling function */ struct rect rect1; rect1 = get_rect();

29 Passing a structure is inefficient since a copy is made. Passing a pointer to a structure is the preferred method. It is done the same way as a pointer to an array is passed, then the member of operator (.) is used to access the individual members.

30 /* A structure variable and a pointer to a structure are declared */ struct rect rect1, *ptr_rect1; ptr_rect1 = &rect1; /* Assign the address to the pointer */ void area(struct rect *ptr_rect) /* The function header */ { x = (*ptr_rect).x1; /* or x = ptr_rect->x1 */ y = (*ptr_rect).y1; /* or y = ptr_rect->y1 */ } /* The call to the function */ result = area(ptr_rect1);

31 This program will add two complex numbers. Each complex number will be represented by a structure. The structure members will be the real and imaginary parts of the complex number. Write a program that defines a structure to hold a complex number. Declare three structures of this type. Two will hold the numbers to be added, the third will hold the result. Write a function to add the two complex numbers. The function should use pointers to the structures.