Slide Set 6. for ENCM 339 Fall 2017 Section 01. Steve Norman, PhD, PEng

Transcription

1 Slide Set 6 for ENCM 339 Fall 2017 Section 01 Steve Norman, PhD, PEng Electrical & Computer Engineering Schulich School of Engineering University of Calgary October 2017

2 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 2/38 Contents Introduction to structure types in C Creating alternate names for types with typedef Operations allowed with structure types Pointers to structure objects A little extension to a previous example Structures within structures Include guards

3 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 3/38 Outline of Slide Set 6 Introduction to structure types in C Creating alternate names for types with typedef Operations allowed with structure types Pointers to structure objects A little extension to a previous example Structures within structures Include guards

4 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 4/38 Introduction to structure types in C A variable of a structure type can contain multiple pieces of data, with different types allowed for the different pieces. The keyword struct is used to create a structure type, and sometimes structure types are called struct types. How is a structure type different from an array type?

5 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 5/38 As an example, a structure type could be used for information related to single student. What would be reasonable choices for type of storage in the table below? piece of data last name given names ID number type of storage Let s write some C code for a type that can hold a student s last name, given names, and ID number.

6 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 6/38 Example structure variable declarations The code written in response to the previous slide created a type called struct StudentInfo. So what do each of the following variable declarations do? struct StudentInfo a; // line 1 struct StudentInfo *b; // line 2 struct StudentInfo c[100]; // line 3

7 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 7/38 Accessing members of structure variables The individual variables within a structure variable are called members. (Other words sometimes used for members are fields, or components.) A member can be accessed using the structure member operator, which is a dot. There is example code on the next slide. Let s draw the AR of main at point (1). (But let s simplify the pictures of the arrays of char so we don t have to draw 96 array elements!)

8 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 8/38 #include <string.h> #define directives and declaration of struct StudentInfo int main(void) { struct StudentInfo s; strcpy(s.last_name, "Coyote"); strcpy(s.given_names, "Wile E."); s.id_number = ; // (1) } return 0; Now let s rewrite main to get the same effect, using a thing called a structure initializer.

9 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 9/38 Outline of Slide Set 6 Introduction to structure types in C Creating alternate names for types with typedef Operations allowed with structure types Pointers to structure objects A little extension to a previous example Structures within structures Include guards

10 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 10/38 Creating alternate names for types with typedef typedef declarations do not define new types. Instead they define aliases (alternate names) for existing types. The simplest syntax for typedef looks like this: typedef variable declaration (Note that the variable declaration includes a semicolon.) The new name for a type goes in the spot where the name of the variable would appear in a normal variable declaration. So, what do these lines of code mean? typedef int FOO; // line 1 typedef double *PTR2DBL; // line 2 typedef struct StudentInfo stu_info_t; // line 3

11 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 11/38 Creating aliases for structure type names in C is common, because it is annoying to have to key in the word struct many times. This is how I would set up the struct StudentInfo type, and then create an handy alternate name for the type... #define LAST_NAME_MAX_LENGTH 31 #define GIVEN_NAME_MAX_LENGTH 63 struct StudentInfo { char last_name[last_name_max_length + 1]; char given_names[given_name_max_length + 1]; int id_number; }; typedef struct StudentInfo stu_info_t;

12 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 12/38 On the previous slide, there is a clear separation between the creation of the type and and the creation of an alternate name for the type. It s possible to save even more keystrokes by merging the type declaration and the typedef into a single declaration... #define LAST_NAME_MAX_LENGTH 31 #define GIVEN_NAME_MAX_LENGTH 63 typedef struct StudentInfo { char last_name[last_name_max_length + 1]; char given_names[given_name_max_length + 1]; int id_number; } stu_info_t; The code above has exactly the same effect as the code on Slide 11.

13 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 13/38 Outline of Slide Set 6 Introduction to structure types in C Creating alternate names for types with typedef Operations allowed with structure types Pointers to structure objects A little extension to a previous example Structures within structures Include guards

14 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 14/38 Operations allowed with structure types Let s define the term structure object to refer to variables and function arguments of structure types. (Later we ll extend the definition to include some other kinds of data related to structure types.) Here are some (not all) of the things you can do with a structure object: access members using the. operator take its address with the & operator copy it, one of three ways: assignment with =, passing a function argument, passing a function return value

15 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 15/38 And here are some things you can t do with structure objects: arithmetic with operators such as + - * / % ++ --, etc. comparison with any of ==!= < <= > >= In C++ you can use operator overloading to define meanings for the above operators when used with structure types. You can t do that in C.

16 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 16/38 To make a simple example of copying structure objects, let s consider the example of representing vectors in the (x,y) plane, and writing a C function to compute the effect of rotating a vector by 90 degrees. y 90 degrees x What code do we need to declare a type called struct vec2d and an alias for that type called vec2d_t?

17 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 17/38 The formula for 90-degree (counterclockwise) rotation is simple. If vector w is the 90-degree rotation of vector v, then x component of w = (y component of v) y component of w = x component of v Let s write a function definition to correspond to this prototype: vec2d_t rotate90(vec2d_t vec); Then let s write a simple main function to call rotate90 and draw diagrams to show how arguments and return values get copied.

18 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 18/38 Attention: Rules for structures are not the same as the rule for arrays! Arrays are potentially large objects that could be expensive to copy. Structure objects are also potentially large things that could be expensive to copy. Using an array name as a function argument results in copying only the address of element 0, a relatively small thing. Therefore, you might guess that using a structure object name as a function argument also just sends an address to the called function. That guess would be wrong. We ve just seen that using a structure object as a function argument results in copying the whole object.

19 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 19/38 Outline of Slide Set 6 Introduction to structure types in C Creating alternate names for types with typedef Operations allowed with structure types Pointers to structure objects A little extension to a previous example Structures within structures Include guards

20 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 20/38 Pointers to structure objects These are used a lot in real-world C code. As with any other data type, the address of a struct object is the lowest address of all of the bytes allocated for the object. A pointer-to-structure contains a a single address only, the address of an entire structure object.

21 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 21/38 Experience has shown me that it s very tempting to conclude that a pointer to a structure object that has, say, three members, must contain three different addresses. My answer to that is: No, no, no, really, No! Let s draw a diagram for an example: struct Foo { double d; int i; char c[4]; }; int main(void) { struct Foo f = { 2.25, 999, "ABC" }; struct Foo *p = &f; // (1) return 0; }

22 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 22/38 The -> operator This is an arrow made from minus and greater-than, with no space in between. If p is a pointer to a structure object, then p-> member name has exactly the same meaning as (*p). member name The parentheses above are important dot has higher precedence than star, so *p. member name is equivalent to *(p. member name ), which makes no sense if p is some kind of pointer.

23 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 23/38 Let s look at an alternate way to implement the rotate90 function, with this prototype: void rotate90alt(vec2d_t *out, const vec2d_t *in); in points to the original vector, and out points to a vector that will get the result of rotating the original vector by 90 degrees. What should the function definition of rotate90alt be? Let s write a simple main function to call rotate90alt and draw diagrams to show how arguments are used.

24 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 24/38 Pointers to data within structure objects It s permissible and often useful to have pointers point to members within structure objects, but these pointers must have appropriate types. Here is an example, which continues on the next slide... #include <string.h> struct table_entry { int number; char symbol[3]; double weight; }; typedef struct table_entry table_entry_t;

25 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 25/38 void titanium(table_entry_t *te); int main(void) { table_entry_t x; titanium(&x); return 0; } void titanium(table_entry_t *te) { te->number = 22; strcpy(te->symbol, "Ti"); te->weight = 47.90; } Let s make a diagram for the moment when the strcpy function starts work.

26 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 26/38 Why use pointers to structures as function arguments? Answer: To save time and memory space. Remember that a pointer to a structure object is just a single address, the lowest of all the addresses of all the bytes used for the structure object. So a pointer typically occupies much less space in an AR than a structure object. And copying an address, which happens when a pointer is sent as a function argument, takes much less time than copying a large structure object.

27 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 27/38 Outline of Slide Set 6 Introduction to structure types in C Creating alternate names for types with typedef Operations allowed with structure types Pointers to structure objects A little extension to a previous example Structures within structures Include guards

28 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 28/38 An earlier version of this example did not include the declaration and initialization of q. struct Foo { double d; int i; char c[4]; }; int main(void) { struct Foo f = { 2.25, 999, "ABC" }; struct Foo *p = &f; double *q = &f.d; // (1) return 0; } If we were told what address is in p at point (1), what could we say about the address in q at that same moment? So what is the difference between p and q?

29 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 29/38 Outline of Slide Set 6 Introduction to structure types in C Creating alternate names for types with typedef Operations allowed with structure types Pointers to structure objects A little extension to a previous example Structures within structures Include guards

30 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 30/38 Structures within structures It is common to declare a structure type in which one or more members have other structure types. Suppose in some program we would like to keep track of circles in an (x,y)-plane each circle has a center and a radius. y radius center x

31 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 31/38 Suppose that this code from earlier in this Slide Set is available... struct vec2d { double x; double y; }; typedef struct vec2d vec2d_t; How could we set up a structure type for circles, using a member of type vec2d_t to specify the center of a circle? Let s write a simple main function to demonstrate use of some variables of our new structure type.

32 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 32/38 Outline of Slide Set 6 Introduction to structure types in C Creating alternate names for types with typedef Operations allowed with structure types Pointers to structure objects A little extension to a previous example Structures within structures Include guards

33 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 33/38 Include guards Here s a reminder of an important definition: A translation unit is the output the C preprocessor produces starting from a single.c file. So a translation unit may contain contents from one or more files included using #include, macro expansions based on #define directives, and so on. It s an error to repeat certain kinds of C code in a translation unit. Among these kinds of code are structure type declarations typedef declarations various other things

34 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 34/38 An include guard is a preprocessor trick used to avoid inadvertent repetition of code within a translation unit. Before we look at how to write an include guard, let s look at how things can go wrong without include guards. Suppose Coder A writes these two tiny header files: file vec2d.h struct vec2d { double x; double y; }; typedef struct vec2d vec2d_t; file circle.h #include "vec2d.h" struct circle { vec2d_t center; double radius; }; typedef struct circle circle_t; Then Coder A gives the header files to Coder B...

35 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 35/38 Coder B wants to write a program with some variables of type vec2d_t and some other variables of type circle_t, and writes something like this... file myprog.c #include <stdio.h> #include "vec2d.h" #include "circle.h" int main(void) { vec2d_t v; circle_t c; //... } Why will a C compiler reject Coder B s program? What would be a very simple fix for this problem?

36 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 36/38 It turns out that the simple fix offered in response to a question on the last slide does not scale it s not a reasonable solution for a project with many large header files, many of which #include some of the other header files. A solution that scales well is shown on the next slide. In each of the two header files, the first, second and last lines form what are known as include guards. Let s briefly explain why the include guards make the following sequence of directives safe and effective... #include "vec2d.h" #include "circle.h"

37 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 37/38 file vec2d.h #ifndef VEC2D_H #define VEC2D_H struct vec2d { double x; double y; }; typedef struct vec2d vec2d_t; #endif file circle.h #ifndef CIRCLE_H #define CIRCLE_H #include "vec2d.h" struct circle { vec2d_t center; double radius; }; typedef struct circle circle_t; #endif Attention: It s customary to make the name of the macro used in an include guard similar to the name of the header file it appears in for example, VEC2D_H is obviously derived from vec2d.h. That helps with readability, but is not mandatory the preprocessor does not care whether the macro name is similar to the file name.

38 ENCM 339 Fall 2017 Section 01 Slide Set 6 slide 38/38 Final notes about include guards These are really common in practical C projects! For example, on a Linux system, the first non-comment two lines of <string.h> are #ifndef _STRING_H #define _STRING_H 1 and the last line is #endif /* string.h */