Category : C Source Code
Archive   : CPTUTOR1.ZIP
Filename : CHAP02.TXT

Output of file : CHAP02.TXT contained in archive : CPTUTOR1.ZIP

Chapter 2


Examine the file named ENUM.CPP for an example ==============
that uses an enumerated type variable. The ENUM.CPP
enumerated type is used in C++ in exactly the ==============
same way it was used in ANSI-C with one small
exception, the keyword enum is not required to
be used again when defining a variable of that type, but it can be
used if desired. It may be clearer to you to use the keyword again
in the same manner that it is required to be used in C.

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. 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.


Examine the example program named STRUCTUR.CPP ================
for an illustration which uses a very simple STRUCTUR.CPP
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 11 and 12 illustrate
the declaration of variables without the keyword, and line 13
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++

You should take note of the fact that this is a valid ANSI-C
program except for the fact that it uses the stream library, the
C++ comments, and the lack of use of the keyword struct in two of
the lines.

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.


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

Page 2-1

Chapter 2 - Compound types

not be the last, since the class is the major ================
reason for using C++ over ANSI-C or some other CLASS1.CPP
programming language. You will notice the ================
keyword class used in line 4, in very much the
same way that the keyword struct was used in the
last program, and they are in fact very similar constructs. There
are definite differences, 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
declare variables of this type in lines 12 through 14, we can
either omit the keyword class or include it if we desire as
illustrated in line 14. 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 in this case the differences are
negligible, but 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 declare objects in much
the same way that a structure is a type that can be used to declare
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 will
be libraries of prewritten classes available in the marketplace
soon. You will be able to purchase classes which will 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. In fact, a few
class libraries are available now.

The new keyword public in line 5, 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 it 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 structure.


Examine the program named UNIONEX.CPP for an ===============
example of a free union. In ANSI-C, all unions UNIONEX.CPP
must be named in order to be used, but this is ===============
not true in C++. We have the so called free
union, the union without a name. The union is
Page 2-2

Chapter 2 - Compound types

embedded within a simple structure and you will notice that there
is not a variable name following the declaration of the union in
line 11. 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
18, 22, 26, 28, and 29.

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 is
stored there. You will notice that the transport is assigned a
value for pallets in line 26, then a value for fuel_load in line
28. 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 stored now. 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 it and understand it, compile and execute it.


Examine the program named TYPECONV.CPP for a few ================
examples of type conversions in C++. The type TYPECONV.CPP
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 18 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 actually all identical to each other. 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
18 and all four of these lines are essentially the same.

The examples given in lines 20 through 28 are unique to C++ because
they are not valid in ANSI-C. In these lines the type coercions
are written as though they are function calls instead of the "cast"
method as illustrated earlier. Lines 20 through 28 are identical
to lines 10 through 18.

Page 2-3

Chapter 2 - Compound types

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.


1. 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

2. Add the variable number_of_ways 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.

Page 2-4

  3 Responses to “Category : C Source Code
Archive   : CPTUTOR1.ZIP
Filename : CHAP02.TXT

  1. Very nice! Thank you for this wonderful archive. I wonder why I found it only now. Long live the BBS file archives!

  2. This is so awesome! 😀 I’d be cool if you could download an entire archive of this at once, though.

  3. But one thing that puzzles me is the “mtswslnkmcjklsdlsbdmMICROSOFT” string. There is an article about it here. It is definitely worth a read: