|
 |
[Introduction] [Chapter 1] [ Chapter
2 ] [Chapter 3] [Chapter
4] [Chapter 5] [Chapter
6] [Chapter 7] [Chapter
8] [Chapter 9] [Chapter
10] [Chapter 11] [Chapter
12]
Chapter
2: Compound Types
ENUMERATED TYPES
Example program > ENUM.CPP
Examine the file named ENUM.CPP for an example that uses an enumerated
type variable. The enumerated type is used in C++ in a similar way
that it was used in ANSI-C, but there are a lot of differences. The
keyword enum is not required to be used again when defining a variable
of that type, but it can be used if desired. The name game_result
is defined as an enumerated type making the use of the keyword enum
optional. However, it may be clearer for you to use the keyword when
defining a variable in the same manner that it is required to be used
in C, and you may choose to do so.
The example program uses the keyword enum in line 9, but omits it
in line 8 to illustrate to you that it is indeed optional, but that
is a trivial difference. There is a bigger difference in the way an
enumerated type is used in C++. In C, the enumerated type is simply
an int type variable, but in C++ it is not an int, but its own type.
Mathematical operations can not be performed on it, nor can an integer
be assigned to it. It cannot be incremented or decremented as it can
be in C. In the example program, an integer is used as the loop index
for the for loop because it can be incremented, then the value of
the loop index named count is assigned to the enumerated variable
by using a cast. The cast is required or a compile error is reported.
The mathematical operations and the increment and decrement operators
can be defined for the enumerated type, but they are not automatically
available. Operator overloading will be studied later, and the last
sentence will make much more sense at that time.
If you have an older compiler, the enumerated variable game_result
can be used for the loop variable but your code would not be portable
to a newer compiler.
The remainder of this program should be no problem for you to understand.
After studying it, be sure to compile and execute it and examine the
output.
A SIMPLE STRUCTURE
Example program > STRUCTUR.CPP
Examine the example program named STRUCTUR.CPP for an illustration
using a very simple structure. This structure is no different from
that used in ANSI-C except for the fact that the keyword struct is
not required to be used again when defining a variable of that type.
Lines 12 and 13 illustrate the definition of variables without the
keyword, and line 14 indicates that the keyword struct can be included
if desired. It is up to you to choose which style you prefer to use
in your C++ programs.
Once again, be sure to compile and execute this program after studying
it carefully, because the next example program is very similar but
it introduces a brand new construct not available in standard C, the
class.
A VERY SIMPLE CLASS
Example program > CLASS1.CPP
Examine the example program named CLASS1.CPP for our first example
of a class in C++. This is the first class example, but it will not
be the last, since the class is the major reason for using C++ over
ANSI-C or some other programming language. You will notice the keyword
class used in line 4, in exactly the same way that the keyword struct
was used in the last program, and they are in fact very similar constructs.
There is a definite difference, as we will see, but for the present
time we will be concerned more with their similarities.
The word animal in line 4 is the name of the class, and when we define
variables of this type in lines 13 through 15, we can either omit
the keyword class or include it if desired as illustrated in line
15. In the last program, we declared 5 variables of a structure type,
but in this program we declare 5 objects. They are called objects
because they are of a class type. The differences are subtle, and
as we proceed through this tutorial, we will see that the class construct
is indeed very important and valuable. The class was introduced here
only to give you a glimpse of what is to come later in this tutorial.
The class is a type which can be used to define objects in much the
same way that a structure is a type that can be used to define variables.
Your dog named King is a specific instance of the general class of
dogs, and in a similar manner, an object is a specific instance of
a class. It would be well to take note of the fact that the class
is such a generalized concept that there are libraries of prewritten
classes available in the marketplace. You can purchase classes which
perform some generalized operations such as managing stacks, queues,
or lists, sorting data, managing windows, etc. This is because of
the generality and flexibility of the class construct.
The new keyword public in line 6, followed by a colon, is necessary
in this case because the variables in a class are defaulted to a private
type and we could not access them at all without making them public.
Don't worry about this program yet, we will cover all of this in great
detail later in this tutorial. Be sure to compile and run this example
program to see that it does what we say it does with your compiler.
Keep in mind that this is your first example of a class and it illustrates
essentially nothing concerning the use of this powerful C++ construct.
THE FREE UNION OF C++
Example program > UNIONEX.CPP
Examine the program named UNIONEX.CPP for an example of a free union.
In ANSI-C, all unions must be named in order to be used, but this
is not true in C++. When using C++ we can use a free union, a union
without a name. The union is embedded within a simple structure and
you will notice that there is not a variable name following the declaration
of the union in line 13. In ANSI-C, we would have to name the union
and give a triple name (three names dotted together) to access the
members. Since it is a free union, there is no union name, and the
variables are accessed with only a doubly dotted name as illustrated
in lines 20, 24, 28, and others.
You will recall that a union causes all the data contained within
the union to be stored in the same physical memory locations, such
that only one variable is actually available at a time. This is exactly
what is happening here. The variable named fuel_load, bomb_load, and
pallets are stored in the same physical memory locations and it is
up to the programmer to keep track of which variable is stored there
at any given time. You will notice that the transport is assigned
a value for pallets in line 28, then a value for fuel_load in line
30. When the value for fuel_load is assigned, the value for pallets
is corrupted and is no longer available since it was stored where
fuel_load is currently stored. The observant student will notice that
this is exactly the way the union is used in ANSI-C except for the
way components are named.
The remainder of the program should be easy for you to understand,
so after you study and understand it, compile and execute it.
C++ TYPE CONVERSIONS
Example program > TYPECONV.CPP
Examine the program named TYPECONV.CPP for a few examples of type
conversions in C++. The type conversions are done in C++ in exactly
the same manner as they are done in ANSI-C, but C++ gives you another
form for doing the conversions.
Lines 10 through 17 of this program use the familiar "cast"
form of type conversions used in ANSI-C, and there is nothing new
to the experienced C programmer. You will notice that lines 10 through
13 are all the same. The only difference is that we are coercing the
compiler to do the indicated type conversions prior to doing the addition
and the assignment in some of the statements. In line 13, the int
type variable will be converted to type float prior to the addition,
then the resulting float will be converted to type char prior to being
assigned to the variable c.
Additional examples of type coercion are given in lines 15 through
17 and all three of these lines are essentially the same.
The examples given in lines 19 through 26 are unique to C++ and are
not valid in ANSI-C. In these lines the type coercions are written
as though they are function calls instead of the more familiar "cast"
method as illustrated earlier. Lines 19 through 26 are identical to
lines 10 through 17.
You may find this method of type coercion to be clearer and easier
to understand than the "cast" method and in C++ you are
free to use either, or to mix them if you so desire, but your code
could be very difficult to read if you indescriminantly mix them.
Be sure to compile and execute this example program.
PROGRAMMING EXERCISES
- Starting with the program ENUM.CPP, add the enumerated value of FORFEIT
to the enumerated type game_result, and add a suitable message
and logic to get the message printed in some way.
- Add the variable height of type float to the class of CLASS1.CPP and
store some values in the new variable. Print some of the values
out. Move the new variable ahead of the keyword public: and see
what kind of error message results. We will cover this error in
chapter 5 of this tutorial.
<< back next >>
[Introduction] [Chapter 1] [ Chapter
2 ] [Chapter 3] [Chapter
4] [Chapter 5] [Chapter
6] [Chapter 7] [Chapter
8] [Chapter 9] [Chapter
10] [Chapter 11] [Chapter
12] |
|
