Dec 102017
C++ Tutor. Assumes experience with some varient of C. Text and source code.
File CPPTUT22.ZIP from The Programmer’s Corner in
Category C++ Source Code
C++ Tutor. Assumes experience with some varient of C. Text and source code.
File Name File Size Zip Size Zip Type
ALLVEHIC.CPP 1580 473 deflated
BOX.CPP 499 249 deflated
BOX.H 375 211 deflated
BOXES1.CPP 1238 476 deflated
BOXES2.CPP 689 291 deflated
CAR.CPP 366 205 deflated
CAR.H 357 221 deflated
CHAP01.TXT 23169 7516 deflated
CHAP02.TXT 9597 3205 deflated
CHAP03.TXT 14021 4597 deflated
CHAP04.TXT 22095 6973 deflated
CHAP05.TXT 45147 13336 deflated
CHAP06.TXT 36861 11120 deflated
CHAP07.TXT 21739 6771 deflated
CHAP08.TXT 17143 5265 deflated
CHAP09.TXT 23393 7459 deflated
CHAP10.TXT 17615 5211 deflated
CHAP11.TXT 16052 5132 deflated
CHAP12.TXT 25616 8437 deflated
CLAS.CPP 973 357 deflated
CLASPOLE.CPP 1268 457 deflated
CLASS1.CPP 672 263 deflated
CLOCK.CPP 447 242 deflated
CLOCK.H 429 226 deflated
CONCOM.CPP 1052 381 deflated
CONSPOLE.CPP 1781 534 deflated
DATE.CPP 4080 1252 deflated
DATE.H 1986 788 deflated
DATETIME.H 561 264 deflated
DEFAULT.CPP 945 316 deflated
ELEMLIST.CPP 582 248 deflated
ELEMLIST.H 785 298 deflated
EMPLOYE2.CPP 1988 658 deflated
EMPLOYEE.CPP 1931 673 deflated
ENUM.CPP 716 269 deflated
FLYAWAY.CPP 1405 537 deflated
FLYAWAY.EXE 25896 13475 deflated
FLYAWAY.H 373 242 deflated
FSTREAM.CPP 1162 461 deflated
FUNCOVER.CPP 1898 466 deflated
FUNCPNT.CPP 1158 337 deflated
INHERIT1.CPP 2757 742 deflated
INHERIT2.CPP 2569 707 deflated
INHERIT3.CPP 2796 743 deflated
INHERIT4.CPP 2777 745 deflated
INHERIT5.CPP 2770 746 deflated
INHERIT6.CPP 2917 780 deflated
INHERIT7.CPP 3212 811 deflated
ITEMS.CPP 2128 464 deflated
ITEMS.H 826 387 deflated
LIST.EXE 4800 3087 deflated
LOCATION.CPP 3856 1083 deflated
LOCATION.H 1681 629 deflated
MAP.CPP 8401 1563 deflated
MAP.H 451 248 deflated
MESSAGE.CPP 1305 404 deflated
MESSAGE.TXT 6172 2110 deflated
MULTINH1.CPP 1652 560 deflated
MULTINH2.CPP 2209 633 deflated
MULTINH3.CPP 2009 641 deflated
NESTING.CPP 940 378 deflated
NEWDATE.CPP 523 263 deflated
NEWDATE.H 392 225 deflated
NEWDEL.CPP 1345 421 deflated
OBJARRAY.CPP 2192 661 deflated
OBJDYNAM.CPP 1460 535 deflated
OBJINTPT.CPP 1790 560 deflated
OBJLINK.CPP 2242 737 deflated
OBJLIST.CPP 1845 628 deflated
OBJSTRNG.CPP 1303 495 deflated
OPEN.CPP 689 259 deflated
OPENPOLE.CPP 1111 357 deflated
OPOVERLD.CPP 1641 478 deflated
OVERLOAD.CPP 1275 423 deflated
PASSREF.CPP 626 247 deflated
PERSON.CPP 322 189 deflated
PERSON.H 276 188 deflated
POINTERS.CPP 688 323 deflated
PRINTALL.BAT 1953 513 deflated
PRINTEXT.BAT 314 85 deflated
PRINTEXT.CMD 269 80 deflated
PRNTTEXT.EXE 15938 8846 deflated
PROTYPE1.CPP 678 278 deflated
PROTYPE2.CPP 752 307 deflated
SCHEDULE.CPP 8256 2007 deflated
SCHEDULE.H 1333 578 deflated
SCOPEOP.CPP 622 218 deflated
STRUCTUR.CPP 665 255 deflated
SUPERVSR.CPP 1836 483 deflated
SUPERVSR.H 932 355 deflated
TABCONT.TXT 9579 2973 deflated
TEMPLAT1.CPP 536 288 deflated
TEMPLAT2.CPP 1614 587 deflated
TEMPLAT3.CPP 1438 566 deflated
TIME.CPP 2801 799 deflated
TIME.H 1619 609 deflated
TRANSPRT.CPP 944 337 deflated
TRUCK.CPP 416 217 deflated
TRUCK.H 406 240 deflated
TRYNDATE.CPP 527 251 deflated
TYPECONV.CPP 645 256 deflated
UNIONEX.CPP 968 352 deflated
USEDATE.CPP 743 288 deflated
USEDTTM.CPP 976 342 deflated
USETIME.CPP 750 335 deflated
VARARGS.CPP 866 373 deflated
VARDEF.CPP 1258 400 deflated
VEHICLE.CPP 592 226 deflated
VEHICLE.H 350 194 deflated
VIRTUAL1.CPP 919 311 deflated
VIRTUAL2.CPP 949 324 deflated
VIRTUAL3.CPP 1032 342 deflated
VIRTUAL4.CPP 1031 350 deflated
VIRTUAL5.CPP 1090 305 deflated
VIRTUAL6.CPP 1091 320 deflated
WORDS.CPP 5736 1656 deflated
WORDS.H 1000 380 deflated

Download File CPPTUT22.ZIP Here

Contents of the CHAP01.TXT file

Chapter 1

As we begin the study of C++ and object oriented programming, a few
comments are in order to help you get started. Since the field of
object oriented programming is probably new to you, you will find
that there is a significant amount of new terminology for you to
grasp. This is true of any new endeavor and you should be warned
not to be intimidated by all of the new concepts. We will add a
few new topics in each chapter and you will slowly grasp the entire

Chapters one through four of this tutorial will concentrate on the
non object oriented programming additions to C++. We will not
begin the discussion of any object oriented programming techniques
until chapter five.


Examine the file named CONCOM.CPP for an example ==============
of several new things in C++. We will take the CONCOM.CPP
new constructs one at a time beginning with the ==============

A comment begins with the double slash "//", starts anywhere on a
line, and runs to the end of that line where it is automatically
terminated. The old method of comment definition used with ANSI-
C can also be used with C++ as illustrated in lines 11 through 14,
among other places in this program. The new method is the
preferred method of comment definition because it is impossible to
inadvertently comment out several lines of code. This can be done
by forgetting to include the end of comment notation when using the
older C method of comment notation. Good programming practice
would be to use the new method for all comments and reserve the old
method for use in commenting out a section of code during debugging
since the two methods can be nested.

It would be well to caution you at this point however, that you
should not use comments when the same sense of program definition
can be obtained by using meaningful names for variables, constants,
and functions. The careful selection of variable and function
names can make nearly any code self documenting and you should
strive to achieve this in your code.

Page 1-1

Chapter 1 - Simple Things

THE KEYWORDS const AND volatile

There are two new keywords used in lines 9 through 11 which were
not part of the original K&R definition of C, but are part of the
ANSI-C standard. The keyword const is used to define a constant.
In line 9 the constant is of type int, it is named START, and is
initialized to the value 3. The compiler will not allow you to
accidentally or purposefully change the value of START because it
has been declared a constant. If you had another variable named
STARTS, the system would not allow you to slightly misspell STARTS
as START and accidentally change it. The compiler would give you
an error message so you could fix the error. Since it is not
permissible to change the value of a constant, it is imperative
that you initialize it when it is declared so it will have a useful
value. The compiler does not require you to initialize it however,
and will not issue an error message if you do not.

You will note that the keyword const is also used in the function
header in line 21 to indicate that the formal parameter named
data_value is a constant throughout the function. Any attempt to
assign a new value to this variable will result in a compile error.
This is a small thing you can add to your programs to improve the
compilers ability to detect errors for you.

The keyword volatile is also part of the ANSI-C standard but was
not included in the original K&R definition of C. Even though the
value of a volatile variable can be changed by you, the programmer,
there may be another mechanism by which the value could be changed,
such as by an interrupt timer causing the value to be incremented.
The compiler needs to know that this value may be changed by some
external force when it optimizes the code. A study of code
optimization methods is very interesting, but beyond the scope of
this tutorial. Note that a constant can also be volatile, which
means that you cannot change it, but the system can through some
hardware function.

Ignore the output statement given in line 23 for a few minutes.
We will study it in some detail later in this chapter. If you are
experienced in K&R style programming, you may find line 5 and 21
a little strange. This illustrates prototyping and the modern
method of function definition as defined by the ANSI-C standard.
We will discuss this in great detail in chapter 4 of this tutorial.
Prototyping is optional in C but absolutely required in C++. For
that reason, chapter 4 of this tutorial is devoted entirely to

It would be advantageous for you to compile and execute this
program with your C++ compiler to see if you get the same result
as given in the comments at the end of the listing. One of the
primary purposes of compiling it is to prove that your compiler is
loaded and executing properly.

Page 1-2

Chapter 1 - Simple Things


The example program named SCOPEOP.CPP ===============
illustrates another construct that is new to SCOPEOP.CPP
C++. There is no corresponding construct in ===============
either K&R or ANSI-C. This allows access to the
global variable named index even though there is
a local variable of the same name within the main function. The
use of the double colon in front of the variable name, in lines 11,
13, and 16, instructs the system that we are interested in using
the global variable named index, defined in line 4, rather than the
local variable defined in line 8.

The use of this technique allows access to the global variable for
any use. It could be used in calculations, as a function
parameter, or for any other purpose. It is not really good
programming practice to abuse this construct, because it could make
the code difficult to read. It would be best to use a different
variable name instead of reusing this name, but the construct is
available to you if you find that you need it sometime.

The scope operator allows access to global variables even though
hidden by a local variable. Be sure to compile and execute this
program before proceeding on to the next example program where we
will discuss the cout operator in lines 10, 11, 15, and 16.

THE iostream LIBRARY

Examine the example program named MESSAGE.CPP ===============
for our first hint of object oriented MESSAGE.CPP
programming, even though it is a very simple ===============
one. In this program, we define a few variables
and assign values to them for use in the output
statements illustrated in lines 17 through 20, and in lines 23
through 26. The new operator cout is the output function to the
standard device, the monitor, but works a little differently from
our old familiar printf() function, because we do not have to tell
the system what type we are outputting.

C++, like the C language itself, has no input or output operations
as part of the language itself, but defines the stream library to
add input and output functions in a very elegant manner.

The operator <<, sometimes called the "put to" operator but more
properly called the insertion operator, tells the system to output
the variable or constant following it, but lets the system decide
how to output the data. In line 17, we first tell the system to
output the string, which it does by copying characters to the
monitor, then we tell it to output the value of index. Notice
however, that we fail to tell it what the type is or how to output
the value. Since we don't tell the system what the type is, it is

Page 1-3

Chapter 1 - Simple Things

up to the system to determine what the type is and to output the
value accordingly. After the system finds the correct type, we
also leave it up to the system to use the built in default as to
how many characters should be used for this output. In this case,
we find that the system uses exactly as many as needed to output
the data, with no leading or trailing blanks, which is fine for
this output. Finally, the newline character is output, and the
line of code is terminated with a semicolon.

When we called the cout output function in line 17, we actually
called two different functions because we used it to output a
string and a variable of type int. This is the first hint at
object oriented programming because we simply broadcast a message
to the system to print out a value, and let the system find an
appropriate function to do so. We are not required to tell the
system exactly how to output the data, we only tell it to output
it. This is a very weak example of object oriented programming,
and we will get into it in much more depth later.

In line 18, we tell the system to output a different string,
followed by a floating point number, and another string of one
character, the newline character. In this case, we told it to
output a floating point number without telling it that it was a
floating point number, once again letting the system choose the
appropriate output means based on its type. We did lose a bit of
control in the transaction, however, because we had no control over
how many significant digits to print before or after the decimal
point. We chose to let the system decide how to format the output

The variable named letter is of type char, and is assigned the
value of the uppercase X in line 14, then printed as a letter in
line 19.

Because C++ has several other operators and functions available
with streams, you have complete flexibility in the use of the
stream output functions. You should refer to your compiler
documentation for details of other available formatting commands.
The cout and the printf() statements can be mixed in any way you
desire. Both statements result in output to the monitor.


The stream library was defined for use with C++ in order to add to
the execution efficiency of the language. The printf() function
was developed early in the life of the C language and is meant to
be all things to all programmers. As a result, it became a huge
function with lots of extra baggage that is only used by a few
programmers. By defining the small special purpose stream library,
the designer of C++ allows the programmer to use somewhat limited
formatting capabilities, which are still adequate for most
programming jobs. If more elaborate formatting capabilities are

Page 1-4

Chapter 1 - Simple Things

required, the complete printf() library is available within any C++
program, and the two types of outputs can be freely mixed.

Lines 23 through 26 illustrate some of the additional features of
the stream library which can be used to output data in a very
flexible yet controlled format. The value of index is printed out
in decimal, octal, and hexadecimal format in lines 23 through 25.
When one of the special stream operators, dec, oct, or hex, is
output, all successive output will be in that number base. Looking
ahead to line 32, we find the value of index printed in hex format
due to the selection of the hexadecimal base in line 25. If none
of these special stream operators are output, the system defaults
to decimal format.


In addition to the cout operator, there is a cin operator which is
used to read data from the standard input device, usually the
keyboard. The cin operator uses the >> operator, usually called
the "get from" operator but properly called the extraction
operator. It has most of the flexibility of the cout operator.
A brief example of the use of the cin operator is given in lines
28 through 30. The special stream operators, dec, oct, and hex,
also select the number base for the cin stream separately from the
cout stream. If none is specified, the input stream also defaults
to decimal.

In addition to the cout operator and the cin operator there is one
more standard operator, the cerr, which is used to output to the
error handling device. This device cannot be redirected to a file
like the output to the cout can be. The three operators, cout,
cin, and cerr, correspond to the stdout, the stdin, and the stderr
stream pointers of the programming language C. Their use will be
illustrated throughout the remainder of this tutorial.

The stream library also has file I/O capability which will be
briefly illustrated in the next example program.

Be sure to compile and execute this program before going on to the
next one. Remember that the system will ask you to enter an
integer value which will be echoed back to the monitor, but changed
to the hexadecimal base.


Examine the example program named FSTREAM.CPP ===============
for examples of the use of streams with files. FSTREAM.CPP
In this program a file is opened for reading,
another for writing, and a third stream is

Page 1-5

Chapter 1 - Simple Things

opened to the printer to illustrate the semantics of stream
operations on a file. The only difference between the streams in
the last program and the streams in this program is the fact that
in the last program, the streams were already opened for us by the
system. You will note that the stream named printer is used in the
same way we used the cout operator in the last program. Finally,
because we wish to exercise good programming practice, we close
all of the files we have opened prior to ending the program.

The standard file I/O library is available with ANSI-C and is as
easy to use as the stream library and very portable. For more
information on the stream file I/O library, see Bjarne Stroustrup's
book which is listed in the introduction to this tutorial, or refer
to your compiler documentation.

Be sure to compile and execute this program. When you execute it,
it will request a file to be copied. You can enter the name of any
ASCII file that resides in the current directory.


Examine the file named VARDEF.CPP for a few more ==============
additions to the C++ language which aid in VARDEF.CPP
writing a clear and easy to understand program. ==============
In C++, as in ANSI-C, global and static
variables are automatically initialized to zero
when they are declared. The variables named index in line 4, and
goofy in line 26 are therefore automatically initialized to zero.
Of course, you can still initialize either to some other value if
you so desire. Global variables are sometimes called external
since they are external to any functions.

Automatic variables, those declared inside of any function, are not
automatically initialized but will contain the value that happens
to be in the location where they are defined, which must be
considered a garbage value. The variable named stuff in line 8,
therefore does not contain a valid value, but some garbage value
which should not be used for any meaningful purpose. In line 11,
it is assigned a value based on the initialized value of index and
it is then displayed on the monitor for your examination.


Notice the ampersand in line 9. This defines another_stuff as a
reference variable which is a new addition to C++. The reference
variable should not be used very often, if at all, in this context.
In order to be complete however, we will discuss its operation.
The reference variable is not quite the same as any other variable
because it operates like a self dereferencing pointer. Following
its initialization, the reference variable becomes a synonym for

Page 1-6

Chapter 1 - Simple Things

the variable stuff, and changing the value of stuff will change the
value of another_stuff because they are both actually referring to
the same variable. The synonym can be used to access the value of
the variable for any legal purpose in the language. It should be
pointed out that a reference variable must be initialized to
reference some other variable when it is declared or the compiler
will respond with an error. Following initialization, the
reference variable cannot be changed to refer to a different

The use of the reference variable in this way can lead to very
confusing code, but it has another use where it can make the code
very clear and easy to understand. We will study this use in
chapter 4 of this tutorial.


Coming from your background of C, you will find the statement in
line 16 very strange, but this is legal in C++. Anyplace it is
legal to put an executable statement, it is also legal to declare
a new variable because a data declaration is defined as an
executable statement in C++. In this case, we define the new
variable named more_stuff and initialize it to the value of 13.
It has a scope from the point where it was defined to the end of
the block in which it is defined, so it is valid throughout the
remainder of the main program. The variable named goofy is
declared even later in line 26.

It is very significant that the variable is declared near its point
of usage. This makes it easier to see just what the variable is
used for, since it has a much more restricted scope of validity.
When you are debugging a program, it is convenient if the variable
declaration is located in close proximity to where you are
debugging the code.

WHAT ABOUT definition AND declaration?

The words definition and declaration refer to two different things
in C++, and in ANSI-C also for that matter. They really are
different and have different meanings, so we should spend a little
time defining exactly what the words mean in C++. A declaration
provides information to the compiler about the characteristics of
something such as a type or a function but it doesn't actually
define any code to be used in the executable program, and you are
permitted to make as many declarations of the same entity as you
desire. A definition, on the other hand, actually defines
something that will exist in the executable program, either some
useful variables, or some executable code, and you are required to

Page 1-7

Chapter 1 - Simple Things

have one and only one definition of each entity in the program.
In short, a declaration introduces a name into the program and a
definition introduces some code.

If we declare a struct, we are only declaring a pattern to tell the
compiler how to store data later when we define one or more
variables of that type. But when we define some variables of that
type, we are actually declaring their names for use by the
compiler, and defining a storage location to store the values of
the variables. Therefore, when we define a variable, we are
actually declaring it and defining it at the same time.

We will refer to these definitions many times throughout the course
of this tutorial so if this is not clear now, it will clear up


Take careful notice of the for loop defined in line 20. This loop
is a little clearer than the for loop that is available in ANSI-
C, because the loop index is defined in the for loop itself. The
scope of this loop index is from its declaration to the end of the
enclosing block. In this case its scope extends to line 29 since
the closing brace in line 29 corresponds to the most recent opening
brace prior to the declaration of the variable. Since the variable
is still available, it can be used for another loop index or for
any other purpose which an integer type variable can legally be
used for. The variable named count2 is declared and initialized
during each pass through the loop because it is declared within the
block controlled by the for loop. Its scope is only the extent of
the loop so that it is automatically deallocated each time the loop
is completed. It is therefore declared, initialized, used and
deallocated five times, once for each pass through the loop.

You will notice that the variable count2 is assigned a numerical
value in line 22 but when it is printed out, a character value is
actually output. This is because C++ (version 2.0 and later) is
careful to use the correct type.

Finally, as mentioned earlier, the static variable named goofy is
declared and automatically initialized to zero in line 26. Its
scope is from the point of its declaration to the end of the block
in which it is declared, line 29.

Be sure to compile and execute this program.


Operator precedence is identical to that defined for ANSI-C so no
attempt will be made here to define it. There is a small

Page 1-8

Chapter 1 - Simple Things

difference when some operators are overloaded which we will learn
to do later in this tutorial. Some of the operators act slightly
different when overloaded than the way they operate with elements
of the predefined language.

Do not worry about the previous paragraph, it will make sense later
in this tutorial after we have studied a few more topics.


1. Write a program that displays your name and date of birth on
the monitor three times using the cout function. Define any
variables you use as near as possible to their point of usage.

2. Write a program with a few const values and volatile variables
and attempt to change the value of the constants to see what
kind of error message your compiler will give you.

3. Write a program that uses streams to interactively read in
your birthday with three different cin statements. Print your
birthday in octal, decimal, and hexadecimal notation just for
the practice.

Page 1-9

 December 10, 2017  Add comments

Leave a Reply