UMBC CMSC202, Computer Science II, Spring 1998, Sections 0101, 0102,
0103, 0104 and Honors
Thursday April 2, 1998
- A Book on C:
- Programming Abstractions in C:
Handouts (available on-line): none
- Lecture on Object-Oriented Programming (OOP).
- Object-Oriented Programming is a programming methodology that
promotes the separation of code/functions according to the type of
data that a particular piece of code works on. It is a
- In the OOP methodology, an "object" is considered an
autonomous unit. In this mode of thinking, you do not apply
functions to objects --- you ask the objects to perform some
operation on itself. For example, if the object is an integer, we
would ask the integer to increment itself rather than apply the
increment operation on the integer. This sounds silly to most
people at the beginning, but we shall see how the OOP paradigm
promotes better organization of large programs and enables code
reuse. From your experience with Project 3, it should not be
too difficult to convince you that better organization of
large programs is both desirable and necessary.
- Our first attempt at making objects.
- C++ is an extension of C. Anything you do in C, is allowed in
C++, but to take advantage of C++ and to follow an object-oriented
approach, you would do things differently in C++.
- One main difference between C++ and C is in the header files.
To define a new class of objects, you use the "class" directive. In
our first header file, we declare a
new kind of object called "Box". The "class" directive is a
combination of function prototypes and a type definition.
- In our example, the definition of the class Box includes
function prototypes for Box(), identify(),
volume(), grow(), shrink() and
random(). These are called "member functions" or
"methods" in object-oriented lingo. They are just functions.
- The definition of Box also includes data members:
length, height and width. These are
just called "members" in C++ lingo. The correspond to the idea of
fields of a record in C. For example, if b1 has type Box,
then the length field of the Box b1 can be
accessed using b1.length. However, since the length field
of Box is private, only member functions can access the length,
height and width members.
- The member functions in our Box class are implemented in a
file called Box.C. C++ programs
usually have a .C extension. On Unix, we use the CC command to
compile C++ programs. Otherwise, compiling C++ programs is
very similar to compiling C programs. Observe that the
names of the member functions in the class Box are
prefaced with "Box::" in the implementations.
- Turning to the main program
we can see how member functions in the class Box are called.
First, we need objects of type Box. In this program we create
3 objects of type Box in the statement:
Box b1, b2, b3 ;
Now, member functions can be called using the "." operator. The syntax
is the same as C syntax for a field in a record. One way to remember
the syntax for member functions is to pretend that each member function
is a field in a record. So, for example, the statement:
calls the function identify(). In this case, the object
b1 is called the host object. You can think of this statement
as a command to the object b1 to identify itself. The
sample run demonstrates the effects of
executing our first C++ program.
- Returning to the implementations of the member functions in
the file Box.C, observe that the
function identify() refers to variables called
length, height and width. These are
members (or fields) of the host object b1. Since the
function identify was called using b1, the variable
length refers to the length member of b1
and not that of some other Box object. In other respects, member
functions are like ordinary C functions. You can have local variables,
you can have loops, you can call other functions, etc.
- The member function Box::Box is a special function
called a constructor. It is distinguished by two things. First,
the name of the function is the name of the class. Second, the
function prototype does not have a return type and is not allowed
to have a return type, not even void. This constructor is called
whenever new objects of type Box are declared. For example, in the
statement above that created three new objects b1, b2
and b3 of type Box, the Box constructor was called three times.
Each time, the Box constructor assigns random values to the
length, height and width members of the new
object. Thus, constructors provide a very convenient mechanism for
initializing objects as they are created.
- The member function random() is also different from
other member functions in our Box class. This function was
declared in the private section of the Box definition in the header file. Thus, random() can
only be called by other member functions in the Box class. So, a
function call like:
would generate an error at compile time. Similarly, the
length, height and width fields are private,
and references to them outside the member functions would cause compile
time errors. Our second main program
and sample run demonstrates this.
- Our main program using the Box
class shows that we can use the symbol "Box" like a type in a C program.
For example, we can declare an array with 4 elements of type Box using
Box boxes ;
In this case, the constructor Box::Box is called 4 times and the
members of each Box object in the array is initialized using
random() as the sample run
shows. Note that we can also declare pointers to Box, using for example:
Box *bptr ;
Here, the analogy to the syntax for fields of records in C still hold.
To refer to the member function identify(), we can dereference
the pointer to Box using then choose a field using:
or we can use the -> operator:
- The new operator in C++ provides functionality that
is similar to a call to malloc(). In this program, the
bptr = new Box[items] ;
creates a dynamically allocated array of Boxes. As before, each
Box object in the array is initialized by a call to the constructor
function Box::Box. If the new operator cannot
make the array for some reason (say the system is out of memory),
then it returns NULL (just like malloc()). As you would
expect, since bptr is a pointer to the first element of an
array, we can use array notation like bptr[i] to refer to
an element of the array.
- The delete operation used at the end is analogous to free. It
releases the memory that bptr points to, which was previously
allocated by the new operation.
- Our second attempt at making objects: improving the Box class.
- First, we improve the constructor function in two ways.
First, in the header file, we
define a new constructor that allows you to specify the
length, height and width of the new Box.
This is done within the definition of the Box class using the
Note that both constructors have the same name Box.
However, the compiler is never confused about which one you intend
to call because one constructor has no parameters (the default
constructor) and the other one has 3 float parameters.
Thus, in this case the number of actual parameters in a call to the
Box constructor will determine which of the two constructors is used.
For example, in the main program, the
Box b1, b3 ;
calls the default constructor twice, whereas the statement:
Box b2 = Box(1.0, 2.0, 3.1) ;
calls the alternate constructor and creates a Box with
length=1.0, height=2.0 and width=3.1.
A subtle difference between C and C++. In C, we do not tend to
think of variable declarations as statements, because nothing
is executed --- the compiler is simply informed about the type
of certain variables. In C++, variable declarations create calls to
constructors, so it is better to think of them as statements.
- Another problem with our first Box class is that the
random() function is not very random. Since we did not
set the random seed for the calls to lrand48(), our calls
to lrand48() always returns the same sequence of numbers.
In order to set the random seed with a call to srand48(),
we need to know when the first call to a Box constructor occurs.
This is accomplished using a shared member called count.
In C++, a shared variable is designated by the keyword static.
Do not confuse this use of static with any other use of the
keyword static. That the member count is shared means
that there is only one copy of count for all objects of type
Box. This is very different from other members --- each Box member has
its own length, height and width. The
value of count is initialized in the implementation file
box2.C using the statement:
int Box::count = 0 ;
This statement is required. Thus, in our constructors we can use
the shared member count to keep track of the number of
Boxes that have been created. In particular, when count
is zero, we can initialize the random seed using the system clock.
This ensures that each time we run our program we have a different
sequence of random numbers. (See sample
9 Apr 1998 09:57:26 EDT
to Spring 1998 CMSC 202 Section Homepage