home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
ftp.barnyard.co.uk
/
2015.02.ftp.barnyard.co.uk.tar
/
ftp.barnyard.co.uk
/
cpm
/
walnut-creek-CDROM
/
MBUG
/
MBUG063.ARC
/
CHAP11.TXT
< prev
next >
Wrap
Text File
|
1979-12-31
|
29KB
|
653 lines
Chapter 11 - Structures and Unions
WHAT IS A STRUCTURE?
A structure is a user defined data type. You have the
ability to define a new type of data considerably more
complex than the types we have been using. A structure is a
combination of several different previously defined data
types, including other structures we have defined. An easy
to understand definition is, a structure is a grouping of
related data in a way convenient to the programmer or user
of the program. The best way to understand a structure is
to look at an example, so if you will load and display
STRUCT1.C, we will do just that.
The program begins with a structure definition. The
key word "struct" is followed by some simple variables
between the braces, which are the components of the
structure. After the closing brace, you will find two
variables listed, namely "boy", and "girl". According to
the definition of a structure, "boy" is now a variable
composed of three elements, "initial", "age", and "grade".
Each of the three fields are associated with "boy", and each
can store a variable of its respective type. The variable
"girl" is also a variable containing three fields with the
same names as those of "boy" but are actually different
variables. We have therefore defined 6 simple variables.
A SINGLE COMPOUND VARIABLE
Lets examine the variable "boy" more closely. As
stated above, each of the three elements of "boy" are simple
variables and can be used anywhere in a C program where a
variable of their type can be used. For example, the "age"
element is an integer variable and can therefore be used
anywhere in a C program where it is legal to use an integer
variable, in calculations, as a counter, in I/O operations,
etc. The only problem we have is defining how to use the
simple variable "age" which is a part of the compound
variable "boy". We use both names with a decimal point
between them with the major name first. Thus "boy.age" is
the complete variable name for the "age" field of "boy".
This construct can be used anywhere in a C program that it
is desired to refer to this field. In fact, it is illegal
to use the name "boy" or "age" alone because they are only
partial definitions of the complete field. Alone, the names
refer to nothing.
ASSIGNING VALUES TO THE VARIABLES
Using the above definition, we can assign a value to
each of the three fields of "boy" and each of the three
fields of "girl". Note carefully that "boy.initial" is
Page 73
Chapter 11 - Structures and Unions
actually a "char" type variable, because it was assigned
that in the structure, so it must be assigned a character of
data. Notice that "boy.initial" is assigned the character
'R' in agreement with the above rules. The remaining two
fields of "boy" are assigned values in accordance with their
respective types. Finally the three fields of girl are
assigned values but in a different order to illustrate that
the order of assignment is not critical.
HOW DO WE USE THE RESULTING DATA?
Now that we have assigned values to the six simple
variables, we can do anything we desire with them. In order
to keep this first example simple, we will simply print out
the values to see if they really do exist as assigned. If
you carefully inspect the "printf" statements, you will see
that there is nothing special about them. The compound name
of each variable is specified because that is the only valid
name by which we can refer to these variables.
Structures are a very useful method of grouping data
together in order to make a program easier to write and
understand. This first example is too simple to give you
even a hint of the value of using structures, but continue
on through these lessons and eventually you will see the
value of using structures.
Compile and run STRUCT1.C and observe the output.
AN ARRAY OF STRUCTURES
Load and display the next program named STRUCT2.C.
This program contains the same structure definition as
before but this time we define an array of 12 variables
named "kids". This program therefore contains 12 times 3 =
36 simple variables, each of which can store one item of
data provided that it is of the correct type. We also
define a simple variable named "index" for use in the for
loops.
In order to assign each of the fields a value, we use a
for loop and each pass through the loop results in assigning
a value to three of the fields. One pass through the loop
assigns all of the values for one of the "kids". This would
not be a very useful way to assign data in a real situation,
but a loop could read the data in from a file and store it
in the correct fields. You might consider this the crude
beginning of a data base, which it is.
In the next few instructions of the program we assign
new values to some of the fields to illustrate the method
Page 74
Chapter 11 - Structures and Unions
used to accomplish this. It should be self explanatory, so
no additional comments will be given.
A NOTE TO PASCAL PROGRAMMERS
Pascal allows you to copy an entire RECORD with one
statement. This is not possible in C. You must copy each
element of a structure one at a time. As improvements to
the language are defined, this will be one of the
refinements. In fact, some of the newer compilers already
allow structure assignment. Check your compiler
documentation to see if your compiler has this feature yet.
WE FINALLY DISPLAY ALL OF THE RESULTS
The last few statements contain a for loop in which all
of the generated values are displayed in a formatted list.
Compile and run the program to see if it does what you
expect it to do.
USING POINTERS AND STRUCTURES TOGETHER
Load and display the file named STRUCT3.C for an
example of using pointers with structures. This program is
identical to the last program except that it uses pointers
for some of the operations.
The first difference shows up in the definition of
variables following the structure definition. In this
program we define a pointer named "point" which is defined
as a pointer that points to the structure. It would be
illegal to try to use this pointer to point to any other
variable type. There is a very definite reason for this
restriction in C as we have alluded to earlier and will
review in the next few paragraphs.
The next difference is in the for loop where we use the
pointer for accessing the data fields. Since "kids" is a
pointer variable that points to the structure, we can define
"point" in terms of "kids". The variable "kids" is a
constant so it cannot be changed in value, but "point" is a
pointer variable and can be assigned any value consistent
with its being required to point to the structure. If we
assign the value of "kids" to "point" then it should be
clear that it will point to the first element of the array,
a structure containing three fields.
POINTER ARITHMETIC
Adding 1 to "point" will now cause it to point to the
second field of the array because of the way pointers are
Page 75
Chapter 11 - Structures and Unions
handled in C. The system knows that the structure contains
three variables and it knows how many memory elements are
required to store the complete structure. Therefore if we
tell it to add one to the pointer, it will actually add the
number of memory elements required to get to the next
element of the array. If, for example, we were to add 4 to
the pointer, it would advance the value of the pointer 4
times the size of the structure, resulting in it pointing 4
elements farther along the array. This is the reason a
pointer cannot be used to point to any data type other than
the one for which it was defined.
Now to return to the program displayed on your monitor.
It should be clear from the previous discussion that as we
go through the loop, the pointer will point to the beginning
of one of the array elements each time. We can therefore
use the pointer to reference the various elements of the
structure. Referring to the elements of a structure with a
pointer occurs so often in C that a special method of doing
that was devised. Using "point->initial" is the same as
using "(*point).initial" which is really the way we did it
in the last two programs. Remember that *point is the data
to which the pointer points and the construct should be
clear. The "->" is made up of the minus sign and the
greater than sign.
Since the pointer points to the structure, we must once
again define which of the elements we wish to refer to each
time we use one of the elements of the structure. There
are, as we have seen, several different methods of referring
to the members of the structure, and in the for loop used
for output at the end of the program, we use three different
methods. This would be considered very poor programming
practice, but is done this way here to illustrate to you
that they all lead to the same result. This program will
probably require some study on your part to fully
understand, but it will be worth your time and effort to
grasp these principles.
Compile and run this program.
NESTED AND NAMED STRUCTURES
Load and display the file named NESTED.C for an example
of a nested structure. The structures we have seen so far
have been very simple, although useful. It is possible to
define structures containing dozens and even hundreds or
thousands of elements but it would be to the programmers
advantage not to define all of the elements at one pass but
rather to use a hierarchical structure of definition. This
will be illustrated with the program on your monitor.
Page 76
Chapter 11 - Structures and Unions
The first structure contains three elements but is
followed by no variable name. We therefore have not defined
any variables only a structure, but since we have included a
name at the beginning of the structure, the structure is
named "person". The name "person" can be used to refer to
the structure but not to any variable of this structure
type. It is therefore a new type that we have defined, and
we can use the new type in nearly the same way we use "int",
"char", or any other types that exist in C. The only
restriction is that this new name must always be associated
with the reserved word "struct".
The next structure definition contains three fields
with the middle field being the previously defined structure
which we named "person". The variable which has the type of
"person" is named "descrip". So the new structure contains
two simple variables, "grade" and a string named
"lunch[25]", and the structure named "descrip". Since
"descrip" contains three variables, the new structure
actually contains 5 variables. This structure is also given
a name "alldat", which is another type definition. Finally
we define an array of 53 variables each with the structure
defined by "alldat", and each with the name "student". If
that is clear, you will see that we have defined a total of
53 times 5 variables, each of which is capable of storing a
value.
TWO MORE VARIABLES
Since we have a new type definition we can use it to
define two more variables. The variables "teacher" and
"sub" are defined in the next statement to be variables of
the type "alldat", so that each of these two variables
contain 5 fields which can store data.
NOW TO USE SOME OF THE FIELDS
In the next five lines of the program, we will assign
values to each of the fields of "teacher". The first field
is the "grade" field and is handled just like the other
structures we have studied because it is not part of the
nested structure. Next we wish to assign a value to her age
which is part of the nested structure. To address this
field we start with the variable name "teacher" to which we
append the name of the group "descrip", and then we must
define which field of the nested structure we are interested
in, so we append the name "age". The teachers status is
handled in exactly the same manner as her age, but the last
two fields are assigned strings using the string copy
"strcpy" function which must be used for string assignment.
Page 77
Chapter 11 - Structures and Unions
Notice that the variable names in the "strcpy" function are
still variable names even though they are made up of several
parts each.
The variable "sub" is assigned nonsense values in much
the same way, but in a different order since they do not
have to occur in any required order. Finally, a few of the
"student" variables are assigned values for illustrative
purposes and the program ends. None of the values are
printed for illustration since several were printed in the
last examples.
Compile and run this program, but when you run it you
may get a "stack overflow" error. C uses it's own internal
stack to store the automatic variables on but most C
compilers use only a 2048 byte stack as a default. This
program has more than that in the defined structures so it
will be necessary for you to increase the stack size. The
method for doing this for some compilers is given in the
accompanying COMPILER.DOC file with this tutorial. Consult
your compiler documentation for details about your compiler.
There is another way around this problem, and that is to
move the structure definitions outside of the program where
they will be external variables and therefore static. The
result is that they will not be kept on the internal stack
and the stack will therefore not overflow. It would be
good for you to try both methods of fixing this problem.
MORE ABOUT STRUCTURES
It is possible to continue nesting structures until you
get totally confused. If you define them properly, the
computer will not get confused because there is no stated
limit as to how many levels of nesting are allowed. There
is probably a practical limit of three beyond which you will
get confused, but the language has no limit. In addition to
nesting, you can include as many structures as you desire in
any level of structures, such as defining another structure
prior to "alldat" and using it in "alldat" in addition to
using "person". The structure named "person" could be
included in "alldat" two or more times if desired, as could
pointers to it.
Structures can contain arrays of other structures which
in turn can contain arrays of simple types or other
structures. It can go on and on until you lose all reason
to continue. I am only trying to illustrate to you that
structures are very valuable and you will find them great
aids to programming if you use them wisely. Be conservative
at first, and get bolder as you gain experience.
Page 78
Chapter 11 - Structures and Unions
More complex structures will not be illustrated here,
but you will find examples of additional structures in the
example programs included in the last chapter of this
tutorial. For example, see the "#include" file
"STRUCT.DEF".
WHAT ARE UNIONS?
Load the file named UNION1.C for an example of a union.
Simply stated, a union allows you a way to look at the same
data with different types, or to use the same data with
different names. Examine the program on your monitor.
In this example we have two elements to the union, the
first part being the integer named "value", which is stored
as a two byte variable somewhere in the computers memory.
The second element is made up of two character variables
named "first" and "second". These two variables are stored
in the same storage locations that "value" is stored in,
because that is what a union does. A union allows you to
store different types of data in the same physical storage
locations. In this case, you could put an integer number in
"value", then retrieve it in its two halves by getting each
half using the two names "first" and "second". This
technique is often used to pack data bytes together when you
are, for example, combining bytes to be used in the
registers of the microprocessor.
Accessing the fields of the union are very similar to
accessing the fields of a structure and will be left to you
to determine by studying the example.
One additional note must be given here about the
program. When it is run using most compilers, the data will
be displayed with two leading f's due to the hexadecimal
output promoting the char type variables to int and
extending the sign bit to the left. Converting the char
type data fields to int type fields prior to display should
remove the leading f's from your display. This will involve
defining two new int type variables and assigning the char
type variables to them. This will be left as an exercise
for you. Note that the same problem will come up in a few
of the later files also.
Compile and run this program and observe that the data
is read out as an "int" and as two "char" variables. The
"char" variables are reversed in order because of the way an
"int" variable is stored internally in your computer. Don't
worry about this. It is not a problem but it can be a very
interesting area of study if you are so inclined.
Page 79
Chapter 11 - Structures and Unions
ANOTHER UNION EXAMPLE
Load and display the file named UNION2.C for another
example of a union, one which is much more common. Suppose
you wished to build a large database including information
on many types of vehicles. It would be silly to include the
number of propellers on a car, or the number of tires on a
boat. In order to keep all pertinent data, however, you
would need those data points for their proper types of
vehicles. In order to build an efficient data base, you
would need several different types of data for each vehicle,
some of which would be common, and some of which would be
different. That is exactly what we are doing in the example
program on your monitor.
In this program, we will define a complete structure,
then decide which of the various types can go into it. We
will start at the top and work our way down. First, we
define a few constants with the #defines, and begin the
program itself. We define a structure named "automobile"
containing several fields which you should have no trouble
recognizing, but we define no variables at this time.
A NEW CONCEPT, THE TYPEDEF
Next we define a new type of data with a "typedef".
This defines a complete new type that can be used in the
same way that "int" or "char" can be used. Notice that the
structure has no name, but at the end where there would
normally be a variable name there is the name "BOATDEF". We
now have a new type, "BOATDEF", that can be used to define a
structure anyplace we would like to. Notice that this does
not define any variables, only a new type definition.
Capitalizing the name is a personal preference only and is
not a C standard. It makes the "typedef" look different
from a variable name.
We finally come to the big structure that defines our
data using the building blocks already defined above. The
structure is composed of 5 parts, two simple variables named
"vehicle" and "weight", followed by the union, and finally
the last two simple variables named "value" and "owner". Of
course the union is what we need to look at carefully here,
so focus on it for the moment. You will notice that it is
composed of four parts, the first part being the variable
"car" which is a structure that we defined previously. The
second part is a variable named "boat" which is a structure
of the type "BOATDEF" previously defined. The third part of
the union is the variable "airplane" which is a structure
defined in place in the union. Finally we come to the last
Page 80
Chapter 11 - Structures and Unions
part of the union, the variable named "ship" which is
another structure of the type "BOATDEF".
I hope it is obvious to you that all four could have
been defined in any of the three ways shown, but the three
different methods were used to show you that any could be
used. In practice, the clearest definition would probably
have occurred by using the "typedef" for each of the parts.
WHAT DO WE HAVE NOW?
We now have a structure that can be used to store any
of four different kinds of data structures. The size of
every record will be the size of that record containing the
largest union. In this case part 1 is the largest union
because it is composed of three integers, the others being
composed of an integer and a character each. The first
member of this union would therefore determine the size of
all structures of this type. The resulting structure can be
used to store any of the four types of data, but it is up to
the programmer to keep track of what is stored in each
variable of this type. The variable "vehicle" was designed
into this structure to keep track of the type of vehicle
stored here. The four defines at the top of the page were
designed to be used as indicators to be stored in the
variable "vehicle".
A few examples of how to use the resulting structure
are given in the next few lines of the program. Some of the
variables are defined and a few of them are printed out for
illustrative purposes.
The union is not used too frequently, and almost never
by beginning programmers. You will encounter it
occasionally so it is worth your effort to at least know
what it is. You do not need to know the details of it at
this time, so don't spend too much time studying it. When
you do have a need for a variant structure, a union, you can
learn it at that time. For your own benefit, however, do not
slight the structure. You should use the structure often.
PROGRAMMING EXERCISES
1. Define a named structure containing a string field for
a name, an integer for feet, and another for arms. Use
Page 81
Chapter 11 - Structures and Unions
the new type to define an array of about 6 items. Fill
the fields with data and print them out as follows.
A human being has 2 legs and 2 arms.
A dog has 4 legs and 0 arms.
A television set has 4 legs and 0 arms.
A chair has 4 legs and 2 arms.
etc.
2. Rewrite exercise 1 using a pointer to print the data
out.
Page 82
