Download a comparison of data structures in c++

A COMPARISON OF DATA STRUCTURES IN C++
W E m G ZHOU
A MAJOR FEPORT
IN
THE DEPARTMENT
OF
COMPUTER SCIENCE
PRESENTED IN PARTIAL FULFaLMENT OF THE REQUlREMENTS
FOR THE DEGREE OF MASTER OF COMPUTER SCIENCE
CONCORDIA UMVERSITY
MONTREAL, QUEBEC, CANADA
1+1
Nationai Library
,canada
Biblioth ue nationale
%
du cana
Acquisiîions and
Acquisitions et
BibliagraphicS e ~ b services bibliographiques
The author has granteci a nonexclusive licence dowhg the
Nationai L i ofCanada to
reproduce, loan, distri'bute or seIl
copies ofthis thesis in inicrofonn,
papa or electronic formats.
L'auteur a accordé mie licence non
exchisive pennettant à la
Biblothèque nationale du Canada de
reproduire, prêter, distniuer ou
vendre des copies de cette thése sous
la forme de microfiche/nlm, de
reproduction sur papier ou sur foimat
électroniqpe.
The a d o r retains ownership of the
copyright in this thesis. Neither the
thesis nor substantial extracts nom it
may be printed or otherwise
reproduced without the author's
pemksion.
L'auteur conserve la propriété du
droit d'auteur qui protège cette thèse.
Ni Ia thèse ni des extraits substantiels
de celle-ci ne doivent être imprllnés
ou autrement reproduits sans son
autorisation.
ABSTRACT
A Cornparison of Data Structures in C++
Weining Zhou
Since many C++ Libraries have become widely-used by programers. Pointers are one of
the rnost powerful and fiexible feahires used in CH. Pointers are paticularly important
for the andysis and design of data structures. The intention of this project is to compare
the two implementation methods, "Closed" and "Open" by using two Ctç Libmries. In
this project, I designed and implemented a phonebook application by using a doubly
Iinked list and a binary search m e as common data structures in the C++ libmrïes: Ctç
Standard Template Libnry (STL)and C++ Data Object Libnry (OrgC++). In order to
explore the performance of the two styles of building data structure librvies in C++,I
performed an objective cornparison of two implementation rnethods in tems of ease of
coding, time and space efficiency as well as the reliability. The applications were coded
in C+k
iii
Acknowledgments
Through many face-to-face discussions as well as exchmges of electronic mail, a number
of individucils have shaped my ideas on the project. For their contributions, fmt and
foremost, 1 gratehilly acknowledge the encoungement, assistance and valuabte opinions
of my supervisor, Dr. Peter Grogono. whose enthusiastic support and guidance enabbled
me to successfully understand and cornpiete the project on time. 1 dso thank Yang
Wang, Weidong Sun, Xieming Hao and, Zhm Zhang for their valuable feedback and
their help in finding ways to present the ideas more clearly. Thanks to Chunbo Yang for
helping to stnighten out the installation problems with the libnries. Thanks also to my
hiends David Wilkins and Alan Yu for theu encoungement dunng this project Finally,
thanks to my dog, MuEy, who kept me Company on many days and iate nights of doing
the project.
Table of Contents
.
1 1 OB JE^...........................................................................................................~.. 1
............................................................................................................ 2
1.2 MOTIVATION
1 -3 OUTLM OF THE ~ O J E C T........................................................................................ 2
CRITER&
D
3. EVALUA~ON
~
N......
~......N
.............g......................................*
7........
3.2 THEAPPLICATION
.................................................................................................... 9
3.3 THEDATASTRUCTURES
.................
.............................................
!O
3.4 THELIBRAR[ES...........~.....................................................................~.....~..~...
I.f........
3.4.1 Standard Template Libtary (STL) ................................................................ 12
3.4.2 CH Data Object Library (OrgCtç) ............................................................ 13
35 TESTCORRECTNESS
...............................................................................................
14
3.6 CO~PARLNG
TIMEAMI SPACE EFFICIENCY
............................................................15
3.6.1 Caculating Time ...........................................................................................16
3.6.2 Calculating Space.......................................................................................... 16
3.6.3
Definition of Time and Space Ratio.............................................................. 16
4.1 ENVIRONMENT.............................................................g.................................. 1
8
4.2 ' r O ~ wIMP~EUENTA~ON
m
METHoD-........,.................... .
................................O...19
4.2.2.1 Irnplementing a Daub1y Linked List ..........,........
.......................................20
4.2. 1 Implementing a Binary Search Tree.............................................................. 22
................................................................................. 23
4.3 l r ~ o ~IPLEMENTATION
~ ~ ~ ' l
4.3.1
Implementïng a Doubly Linked List ............................................................ 23
4.3.2 Implementing a Binary Search Tree.............................................................. 26
4.4 USER
INTERFACE....................................................................................................
30
4.4.1
Suspected ProbIems with OrgCtk .............................................................. 30
4.4.2 U?for "Open" Implementation in STL.......................................................... 31
4.4.3
Ui for 'Closeci" Implementation in OrgC++................................................. 35
5 .1 USAEHLITY
.EASEOF CODNG................................................................................ 36
5.2 TlMEAND SPACE
.......................................................~.............~.........~~...................
38
5.2.1
Build Time Eficiency .........................~......*...........................*......................
38
5 2.2 Access Time Efficiency ........................*....................................................... 39
5.2.3 Space Efficiency............................................................................................ 42
5.3 LVTERA~ON
wrr~
MFC .....................................................................
43
5.4 OTHER COMPAR~SONS
..........................~......................*~.........................................
43
6.1 THEADVANTAGES OF STL AND ORGCtt.............................................................. 45
6.2 FUTURE
WORK....................................................................................................... 47
A. BOOKSAND ARTICLES
B.
....................................................................*...................*...
a
~FORM.T~O
ONN THE WEB ....................................................................................
49
Chapter 1 Introduction
As we b o w , there are rnany C t t libraries that are used by programmers. But each
library works better in different situations. Data structures are of intenst since there are
some important performance problems in designing scientiftc class libdes. The
expenence of working with various data structures may offer some usefui insights about
performance of these data structures. In this section, 1 describe objectives of the project
and why 1chose this topic. I aIso introduce the structure of this report.
1.1 Objectives
This project is an attempt to find out whether pointers should be inside objects or in
separate nodes. For example, with a Iinked list, there are two ways to implement it. In the
'lclosed" implernentation, each node ha a pointer to the next node. in the "open"
implementation, the Iist nodes are sepanted fiom the data nodes; the data nodes have no
pointers. In order to explore the performance of two styles of building data structure
Iibraries in Ci+,
present an objective cornparison of two methods of implementation in
tems of ease of coding, size of node, security, timelspace eficiency and reliability. I
designed several applications using Linked List and Tree as the common data smictmes
on base cIûss libraries such as STL and OrgC++ and not on UI Iibnries (such as
Interviews, StarViews, etc,).
1.2 Motivation
When Dr. Peter Grogono asked me in May 2000 whether 1 would feel like writing the
project to compare data structures in some C + i libnries, my first thought was: is this a
very interesting topic? Many books about data structures and algonthms were already
out at that time, but you could hardly find my nfennces about cornparison of ihese data
structures. L simply questioned the need for doing this project. 1tried to look at this aspect
in different 1ibr;uies to see if there was any related material, mostly in vain.
Unfortunately, it is very hard to find any books that compare data structures with CU
libraries. About two weeks Iater, I must admit, he convinced me.This project will be very
interesting and new to us. In sumrnary, I enjoyed the project and hope it cm provide
some valuable reference to people who are interested in further reseûrch of data structures
in C++Iibtan'es.
1.3 Outiine of the Project
The project
starts
off with an induction in Chapter 1. It describes the objectives and
motivation of the project. Chapter 2 describes the background of the project, and what the
challenges are to the cumnt technology as welI as describing the existing problems with
software and the concepts of the "Open" and "Ciosed" implementation methods. In
Chapter 3, I present details about experimental design h.om mmy aspects including: the
application design, selection of data stnicains, and libraries. In addition, I define the
evduation criteria which are used to compare the performance of the two methods later in
chapter 5. Chapter 4 gives the details of the irnplementation of the phonebook in the
different Iibraries and Chapter 5 presents the test resulis of the different impIementations.
To compare the performance of each irnplementation I used the predefined criterie 1 ais0
present the User Interface in Chpter 5. At the end 1 conciude the project and sumarize
the two irnplementation methods in Chapter 6 and. 1 also give sorne recommendations for
further work on this project References are listed in the Chapter 7.
Chapter 2 Background
In recent years there has been a proliferation of C++ libcaries used by prognmmers but
there are few pubtished cornparisons of data structures with them. With moôt class
libraries today data structures are using "Open" implementation, such as STL. There are
few libraries using '%losedl' implementation, such as OrgC++ Fcom the Code
Fm.
Definitions of "Open" and "Closed" implementation methods are in section 2.3.
2.1 Problems with existing software
Most of the problems with today's software stem from poor management of intemal data,
Data related enors such as dmgling pointers may stay in the code unnoticed for a long
iime and are often dificult to find There ;ire no generic, fully typed libmies for data
structures in C, and container based C++ Iibraries hide the critical data orgmization (data
structures) thus making the resulting code difficult to debug. They also cause
heffciencies at mn-time. Some libmries offer persistent objects but nquire custom
coded IO functions for every new class. Even highly recognized libraries such as the STL
or tools.h++ do not protect the programmer h m accidentally destroyed objects or
messed up linked lists. For example, you cannot addldelete objects from a list whiIe
aversing it with an iterator.
2.2 Challenges
The major challenge for present technology is to generate efficient software more
efficientiy. Computen are king used in essentiaily dl areas of human activities; even
products that seemingly have nothing to do with cornputers contain a significant portion
of cornputer related cost.
In general, more efficient software means three things:
Coding and debugging programs fater;
Generating programs with less errors,
Producing cleaner, more readable code, which is eûsier to maintain.
2.3 The Basic Concepts
Here, 1 present a brief explannation of some concepts 1used in this project.
With
"Open" impiementation method, as the nme implies, the Iist nodes are
separated fiom the data nodes; the data nodes have no pointers to substructures. The data
structures are formed by auxiliary objects, usually cailed links, that point to the
appkation objects but do not add any pointers or other data to then Each Link has a
pointer that le& to the object that participates in the Iist
With
"Closed" implementation method, the data structures are formed by
pointers stored inside the appIication objects. For exampie, in a Iinked List, each node has
a pointer to the next node.
Ail this seems so trivial that you may wonder why I are spending so much time
discussing it but there is more here than meets the eye. The problem is that the choice of
implementation has numerous consequences which are often negiected. For example, a
"closed" implementation is computationally more efficient, and permits bi-directional
access between the objecis involved. On the other hand, lists using "open"
implementation method are easy to implement using templates, and they form the basis of
almost every existing container class libtiuy.
Chapter 3 Design
In this project my major interest is to explore the performance of two styles of building
data structure libraries in C t t . I present an objective cornparison of two methods of
implemenîation in terms of ease of coding, size of node, security, timdspace effciency
and reliability. Fustiy,1 need to choase the kind of application and what Iibrnries and
common data structures are to be coasidered in this project. h addition, 1 also need to
consider two other important aspects which, are the comctness of the implementation
and cornparison of the tirne and the space of each data structure in the two tibraries. In
order to evaluate the performance of each implernentation, 1 define evaluation criteria for
the experiments.
3.1 Evaluation Criteria ~efidtion
The critena defined are applicable to a class Iibnry in generai or to its component classes
in particular to this project. The following have been defined:
Usabüity
By this term I mem several aspects which, although difficult to quanti@, are important,
such as the set of classes provided, the ease of use of a class, the kind of services
provided, and the simplicity and clarity of the interface. Of course, the more the interface
is simple and clear, the bener.
Time and Space
For a given data structures such set, iist, tree, gnph, etc., the prognms could check the
time needed to build a list and search elements or the space occupied to build a k t .
a
Others
in deciding which C++ class library to use. other criteria cm be defined, such as the
following:
is it shareware or commercial (do we have to pay for it, is it provided in source or
object format)?
0
if it is provided in source format, are there problems to compile it with the
compiler I have ?
is the class library supported by the vendor/developer?
Of course, without vendoddeveloper support I have
to take into account the
nsk of
finding bugs 1 then have to fix by myself.
is it easy to install ?
is there a suite of tests to be run in order to make sure that no problems will occur
when using the Iibnry ?
is it reliable? 1s it easy to crash when you do a large search?
Then is something to add to the discussion made so fx. The criteria definecl till now are
somehow context-independent, in the sense that they are gened criteria against which a
clas libnry can be evaiuated and found to be more or l e s 'tdesinble".
However, other criteria could be defined which are more context-dependent, and could
arise from paaicula. needs related to the kind of application that has to use the class
library- The definition of such criteria is not uicluded in the scope of this project but
ought to be considered when making the final decision on which iibrary (libraries) to use.
3.2 The Application
The application selected was a phone book. The phone book includes fint names, 1st
names and phone numbers of people. 1 designed this application specifically for the
purpose of testing and cornpûnng the performance of the selected Ci-t libmries.
I t is not overly cornplex.
9
-
1chose this application for two reasons:
Fint, simplicity made it possible to write implementations in sevenl C++ libraries in
a reasonable time.
Second, the simplicity enhances data structures cornparison because al1 the libmies
considered provide support for the set of featum needed by the application.
The application can carry out the following basic functions:
uisert: input a record which includes f î t n m e , last name and telephone number of a
prson hto the Phone Book.
Search: Given a selected phone number, semh for a person's record (Fustn m e &
Last name.)
Delete: Given a selected phone number, delete mord that contains a person's f i t
name, last name and this phone number. The phone number is used as a key to
associate with the fust name and last name of a person from the phonebook.
3.3 The Data Structures
The application is implemented in different libraries using Double Linked List and binary
me.
The rasons why 1choose the above structures are:
(1) Both data structures are supported by both STL and Org CH.
(2) They are very common data stnictures in any class Iibrary. In other words, they c m
represent many data structures.
(3) Due to tirne concerns. they are easy to impiement.
(4) A Iinked list and a binary semh
me require pointers for allocating their nodes
dynamicaliy.
(5) I also considered other data stnicnires, but found that the implementation of these
data strucnires do not add significmt new aspects over the data structures 1 have
chosen. For example, the implementation of a single linked list is similac to a double
Iinked list; the implementation of a hash taie or a graph can use a single or double
iiked kt.
3.4 The Libraries
There are severai libraries for containers and algorithrns in CH. Each of them has
different chûracteristics of its data structures in the implementation. After searching and
studying many references about different libcaries from different resources, I selected the
libraries considering the foliowing factors:
Availability: The libraries can be easily obtained. They can be either part of most
ment C++ implementations or cm be downloaded free from web-sites.
Common data structures: Al1 libraries have the common support data structures such
as k t , tree, etc.
Different irnplementation: The libraries are able to represent "Open" and "Closed"
implementation methods.
addition, 1 considered other criterie In the end, based on these factors, I decided to
use STL and Or&++ libraries in the project to do the cornparison. You may wonder
why I selected STL and OrgC++. I describe them in the following sections.
Here, 1 wiii mention another Libnry, LEDA (Libnry of Efficient Data types and
Algorithms). LEDA is a library of the data types and algorithms of combinatorial
computing. At the beginning of the library selection, I considered LEDA. It is similar to
STL Data structures of LEDA also are implemented using 'Y)penl' Implementation. It is
not public domain, for this reason and dso concem about tirne, 1 dropped it h m the
study.
It took quite a long time for me to get a complete ''feeling" of the different and multifold
aspects of each Library, aithough a 'Ylavour"of it may be had in a shorter time.
3.4.1
Standard Template Library (STL)
As is well known, the
C* Standard TempIate Library (STL) is provided as a part of
most ment C++ irnplementations. It is a C++ libnry of container classes. algorithms,
and itemtors. It provides many of the basic dgorithms and data smictures of cornputer
science. As its name suggests, the Standard Template Libnry is based on the
comparatively new subject of ternplates. The STL is a genenc libnry, as impiied by the
name, meaning that iis components are heavily parameterized. Almost every component
in the STL is a template. The basic idea of templates is that they allow us to write
functions and classes in a very general way and then specialize them when they are
actually put to use.
The Standard Template Libnry is defined as a set of class interfaces. Individual vendoa
provide their own impiementritions of the STL. Strictly speaking, the cornparison I
describe in this report is between a particular imp&ementafion of STL (narnely, the
implementation provided by Microsoft) and OrgC++.
The orpankation and design of the STL differs in aùnost dl respects from the design of
most other C*
Iibraries. The most important diffemce between STL and al1 other C++
container class iibraries is that most STL algorithms are generic; they work on a variety
of containers and even on ordinary CH m y s . A key factor in the Iibnry design is the
consistent use of iterators, which generalize C t t pointers, as intemediaries between
aigonthms and containers. Containers make iterators available, algorithms use them, and
this leads to a separation which dlows an exceptionally clear design.
The~fore,iterators are central to genenc programming because they are an interface
between containers and algorithms. Algonthms typically take iterators as arguments, so a
container need only provide a way to access its elements using iterators. This makes it
possible to write a generic algorithm that operates on many different kinds of containers,
even containers as different as a vector and a doubly linked list.
3.4.2
C++ Data Object Library (OrgC++)
CM Data Object Library inciudes the most extensive data structures on the market for
fast, automatic peaistence and are ideal for large, complex Ci+ projects.
The Ci-+ Data Object Library (OrgCu), is much mon than just a class library. It is
based on the new concept of hyper-objects which are objects that store their data in other
objects, cailed carriers, carriers passively keep the data, but hyper-objects provide the
methods. Or&*
provides an additional absinct Iayer for the management of data. We
do not have to assemble the organization from Iibr;uy objects. The organhtion is
automaticaily generated in a way which provides optimum run-time performance.
Combmed with automatic persistence and version control, Orge++ pmvides a set of
powemil tools which are usehl for a variety of tasks ranging from the mangagement of
intemal data to the design of fast memory resident databases.
Compared to the C++ Iibrary, STL.,, OrgC* is a library of intrusive data structures which
are formed by pointers stored inside the application objects, unlike container where
auxilüary objects fom the required data structure and point only to the application
objects without adding any pointers or other data to them. Therefore, OrgC+c uses the
Wosed" implementation and STL uses the "open" implementation.
3.5 Test Correctness
The main prognrn of this project is the phonebookcpp. A phonebook is defined as a list
and binary search tree in STL and as Double-R h g and Double-Tree in OrgC++. It is
used to test a11 the data structures implemented in this project, which include:
Person: Defines a record of a penon that includes the peaon's firstnume, lastname,
and phonenumber. It is used as a user defined data type Iater.
Functor Defines a random number generator. It is used to initialize a stream by a
given seed In other words. it is used to generate each random data stream of
firstname, Imarne and phonenumber of persons.
PersontiasIt: is used to get a peaonS record h m a given phonenumber.
The following functionaiity is tested in the applications using STL:
a
To search a record of a person in the existing phonebook. It retums an iterator to that
object if the given phonenumber is found thcn I cm get the reconi of that person.
O
To insert a record of a person ïnto the phonebook and provide confirmation whether
the record is inserted. 1 can also later use search to verify if the record is correctiy
inserted,
To delete a record of a person from the existed phonebook and check whether it cm
be conectly removed nom the phonebook.
3.6 Cornparhg Time and Space Efficiency
In order to anaiyze the time and space performance of data structures when building and
accessing a large tree and a list in both STL and OrgCu, 1 compare the results in STL to
equivalent results in OrgC*.
I used the foliowing code to create a random number
genentor. It genentes some large random numbers. I use them as records for the
phonebook. The large number is also used as the number of nodes for building mes and
lists and the numkr of times to access trees and lists.
long unsigned Functoc:randorn-number()
C
-
ran (m* multipIier)%moduh;
if (mc1000000)
ran +- 3
0
0
0
0
w
,
retum m;
3.6.1
Cdculating Time
I use the funcùon _itime() to get the cunent time of the system: to rneasure the time for
building and accessing trees and lists.
To get the build time of a tree or a List, 1cal1 ftme(() right More and right afier building
the tree or the list. Then I calculate the time difference between the two cdls of m e ( ) .
Similarly, I get the access time of a tree or a List by calling m e ( ) right before and right
afier accessing the tree or the list for n times.
3.6.2
Calculating Space
I use sizeoA*this) to rneasure the space needed for each tree node or list node. I
implement a sice() hnction in each full node class and calculate the space needed for an
entire tree or list.
3.6.3
Dennition of Time and Space Ratio
In order to compare time and space performance of data structures in each library easily
and cleariy, 1define time and space ration as following:
Given a nurnber n, I define
BuiidTimeRatio (n) =
Time to build a data structure with nodes using STL
Time to buitd a datri structure with nodcs using Or*
AccessTimeRatio (n)
SpaceRatio (n)
-
-
Time to access a data structure with n nodes 10000 times using STL
T
n
a
é to access a &ta
structure with n nodes 10000 using O r e
S p a ueeded to buad a data structure with n n&
using STL
Space needed to build a data structure with a nodes using OrgCtt
I use BuildTirneRatio (n),AccessTirneRatio (n), and SpaceRatio (n)to compare the time
and space efficiency of using STL and Or&++. If the ratio is Iess than 1, it means that
using STL requues less time or space than using OrgCu.
I use IOOOO ioop iterations because 1 wmt to make the cornpaison of the performance of
two implementations in the same Ievel. Although it takes a long time to access data in the
"Open" implementation, it is almost instant in "Closed"implementation if the number of
the loop times used is small.
Chapter 4 Implementation
In this section. 1 will give the implementation details of the phonebook in different
lib&es. In order to show how the implementation cm be generaiized to work with any
data type without conflicts between STL (Standard Template Library) and OrgC++ ( Ci+
Data object Library) in this project, al1 the classes head file names in STL start with 'stl'
and in OrgCtt- start with the brgc'.
'ïhere are three main classes defined through this application.
Class Functoor: It defines a random number generator. It is used to initialize a Stream
by a given seed.
Class Person: It defines a personk Jirstname, lustnarne and phonenumber. C h s
ORGCPerson is used as a template parameter type in the file ORGCphonebookcpp.
a
Ciass PersonHask It defines the function that is used to get a person3 record by a
given phonenumber.
For more implementation details of the classes, please d e r to finctor.h. person.h and
personhusit.h on page 50 to 57.
The diffemt libraries have k e n Ulstalled on Wmdows 95. The tests have been carried
out on Wmdows95 using Microsoft Visual C++ 6.0.
4.2
" Open" Implementation Method
The Standard Template Library is a C++ library of container classes, dgorithms, and
iterators. Container classes are very usefuI classes of data abstractions in the STL. A
container contains values of some kind or references to values of some kind. For
example, list is a kind of container and set is another kind of container. The difference
between a list and a set is that a list imposes a physical, though not necessarily a Iogical
ordeMg of the elements it contains, and a set imposes nothing on the values it contains
other than the fact of containment. STL also includes a large collection of algo&hms that
manipulate the data stored in containers.
Another important data absuaction provided by the Standard Template Library are called
itemtors. They are used to refer to the individual elements of containers and to provide
the means of applying operations to the contents of containers.
From the previous chapter 3.4.1,I know that a key factor in STL design is the consistent
use of itentoa. Pointers themselves are iterators. So what is the purpose of itentoa? in
the STL,very few of the algorithms needed to manipulate an abstraction are implemented
in the cl= corresponding to thnt abstraction. Instead, the class defuies functions that
-
make certain information about the abstraction here a iist - available in such as way that
1can implement any needed algorithm without modiwng the structure itself. In fact, it is
possible to build such dgorithms in such as way that they work with other data
abstractions as well as the one for which they were orïginally designed. This is the
purpose of iterators.
In terms of inheritance, the Standard Template Library does not depend heavily on
object-oriented features of C++.Relatively IittIe inheritance is involved in this Library. In
contras&other libraries use ïnheritance extensively, some to the extent that every class is
derived fiom a common base class. In fact, some other object-oriented languages
(Smalliaik, Modula-3, Java) make this a quirement.
Implementing a Doubly Linked List
In this section I shail look at an implementation of a doubly linked list that uses two
pointers in each node as shown in figure 1. A doubly linked list, is a sequence that
supports both forward and backward traversai, and provide constant time insertion and
removal of elements at the beginning or the end, or in the middle.
Figure 1 shows the structure of Lists in the STL
Figure 1:Lists in STL
20
In the project, when a phonebook is created, I use container clûss List:
iist<Person> phoneBook;
list<Person>::iterator phoneBookiteratur;
1also define phonebuokherator.
As we know iterators are the mechmism that rnakes it possible to decouple algorithms
fkom containers; algorithms are templates, and are panmetenzed by the type of itentor,
so they are not restricted to a single type of container.
Hence, in the project, when I search a record of a peaon in the existing phonebook, 1 use
the STL5Jnd-fl) aIgorithm to perfom this search through the phonebook list. It shows:
Q(phoneBook(terator==phoneBoukend())
cour CC "Recordnot found N1 list' << endl;
else
cou[ << *phoneBookiteratorcc endl;
It completes the first time PersonHaFII() retums true for any object It retums an iterator
to that object, or if PersonHmIt()never renirned mie,/ind_ifO returns end().
To insert a record of a person into the phonebook and to provide confmation to check
whether the record is inserted, an Insert iterator is used to implement this. Here is the
definition of inseaion into a container by means OF.
phoneBookimert(ph~ook.end().@erson);
Its effect is to insert the record of aPerson immediately before the iterator
To delete a record of a person from the existing phonebook and check whether it c m be
correctly removed nom the phonebook. 1 use STL's algorithm remove() to perform this
Remove removes from the range [phoneBookbegin(),phoneBookend()l all elements that
are equal to the value of PerHasl(pn).
Implementing a Binary Search Tree
A tree structure is used to store data in sorted order. It consists of nodes that contain data.
Nodes have links to other nodes. Any tree has a single mot node to which a11 other nodes
are linked. A node data must have a key which cm be compared and sorted. A binary tree
is the simplest type of a tree structure; a b h r y search tree is û pûnicular kind of binary
tree. Each node in a binary search tree contains data and two links. The Iefi link connects
to al1 nodes with fesser data values; and the right link connects to al1 nodes with greater
&ta values. if one datum is greater or less than
another datum it can be determined by
cornparhg the key values of the two data.
In STL,I use Set to represent tree to compare to the Tree organization in OrgC*.
Set is
one of the associative Containers in STL. Aiso STL sets are always sorted and they are
impiemented using tree structures. In this project, 1use a binary search tree. It hoids data
that c m be compared with something Iike operutor c. The build-in types of C*
have
such a comparison, though the comparison for pointers to strings (or indeed any pointers)
is quite meaningless. The~fore,the STL p e d t s the user to define alternate cornparison
operations using function objects. A comparison object is either a binary function
renuning bool, or an object in a class that has such an operator()defined.
In the project, I defmed the following comparison function to compare two ndes:
class PersortLess
{ 6001 operator()(const Person& x, const Persondi y) consr {
return rgetPhonenumber()< y.getPhonenurnber();
}
1
4.3
"Closed" Implementation
In the C++ Data Object Libnry (OrgC++), al1 organizations are based on a ring-type
arrangement, not on a NULL-ending Iist.
4.3.1
Implementing a Doubly Linked List
In order to make a comparison to STL list, 1 can use double-ring organization to
represent doubly linked list because they behave simiiarly.
Figure 2: DOUBLE-RING in O r g h
As 1descnbed in the previous chapter 3.4.2,OrgC++ is based on new concepts of Hyper-
objects which are objects that store theù data in other objects, called carriers. Carriers
passively keep the data but hyper-objects provide the methods.
OrgC++ uses genenc functions. For example, add() c m be used to add an object to a
ring. to a me, or to a graph, without loosing the advantage of niII type checking, dei() for
delemg (disconnecting) an object. In OtgCu, a ring (or circular k t ) is a structure
existing on a set of objects without any s W t d pointer encapsulated in a special class.
Since the entry to the ring is not encapsulated I have to keep it extemally, otherwise the
ring would be there, but 1 would not know how to get to it. The entry is also important if 1
am concened about the order of the objects in the ring. The entry to the ring wil1 be
mtumed as the last element when tmvening the ring.
Here I defined a phonebook using double-ring orgrniration.
22-HYPER-DOUBLE-RING{phoneBook,Person);// declare a DOUBLE-RING
Before 1 start to use this ring. I have to set entry=NUU.
Person *nstart=NLILL; f i initialize start before using the DOUBLE-RING.
I also define Persun* phoneBook-p~. OrgC++ doesnt provide operationfind-ifl) in
DOUBLE-RING.in order to compare to STL algorithrnfind-fl), here I also define it as
the following:
Person*find-flPersonHasIt& anotherqerson) {
Person *temp;
int count = 0;
ZZZZAATRAVERSE(phoneBook,mtart,tempK
if(anotherqerson(*templ) break;
)ZZ -A-END;
return temp;
3
Then when 1 search a record of a person in the existed phonebook, 1defined:
if (!phoneBookqtr)
cout C C "Recordnot fourzd in livr" << end!:
else
cour CC *phoneBookptr<< endl;
To insert a record of a person into the phonebook and provide confirmation to check
whether the record is inserted. I use O r g W generic hinction addo:
Adds new object, a record of aPerson to the ring with entry point mart and returns a
new entry.
1 also use OrgCtç generic function del0 to move a record of a person fiom the existing
phonebook and check whether if it cm be correctiy removed €rom the phonebook.
In OrgC++, 1use DOUBLE-TREE to compare to the STL Sets as illustrated in figure 3
L
A
D
L
parerit
L
E
b
ba
sibling
child
Figure 3: DOUBLE-TREE in OrgC++
Here I defined a phonebook using DOUBLE-TREE organization:
Because OrgCtç doesnt contain find -iff) aigorithrn, as 1 described in 4.3.1, 1 therefore,
have to definefind -in)here to semh for a person's record.
while f mtpgarent) {
if (anothergerson(*mrpgarent))break,P No chiZd Y
i f ( ! ~ r ~ t ~ c h i l d = p i t o n ~ k . c h i l d ( ~ p ~ {a r e n t ) ) )
mpgarent = NUU;
break,-
1
P One child */
else if((second~child=phoneBookfwd~rsr~child))==first~child)
{
if((anuther~erson.getPhonenwnber()>
) ) ) =
&&~r~t~child->getPhonenumber()<hp~~ent->getPhonenmber()))
f
tmpyarent = N U ;
break;
) else
~((another~erson.gcrPhonenmber()~mp~are~t->getPhonenumbe~))
&&Lfirsr-chiid->gerPhonenumbeN)>=nnp~arent->getPhoneniimber()))
{
mipgarent = N U U ;
break:
) else
mrpgurent =first-child;
/*
Two chikiren */
c k{
if(anoihergerson.gerPhonenumber()> =mrpgarent->gctPhonenitmbed))
tmpjarent = scconti-chiid;
else
mtpgarenr =first-child;
1
)/* while loup */
return mrp9arent;
1
Then I can usejnd-ifto search for a person record of the phonebook using:
if(!phoneBuokytr) )i
cout <c "Record nosfouad in list' << endl:
1
eke {
cout <C *phoneBookgtr << endl:
1
To remove a record of a person from phonebook, hen I also dehed phoneBookdei():
void phoneBookdei(Person* delperson) {
As seen in figure 3, all the children of any node fom a RMG. The child pointer fiom the
piirent represents the start pointer of the RMG. Repeated use of add() loads the nodes in
reverse order. When I insert a record of a person into the phonebook, the following
OrgC++ contained operations are used to define phoneBookadd().
. Addo
APP~
Inso
adds a new child;
appends a new sibling to the right of a given node.
inserts a new sibling to the left of a given node
Here I defincd phoneBookadd() to add a node into the phonebook.
I* Na child *1
if(!@rsr-chiId=phoneBookchiid(mip~~rent))) {
phoneBookadd(mtpyarent. newgemon);
remrn;
)
If
One child */
e k if((second~child=ph~neBmk.fwd~rst~~hild))==frr~t~~hild)
{
if((new~on->gerPhonentmber()>
=mp~urent->gerPhonenitntber()]
Le& ( J r s t - c h i i d - > g e t P h o n e n w n b e r ( ) c t n i p ~ ) }
phoneBook.app(Frstkchifd, newgerson);
/ / appends a new sibling ro the righr of a given node.
retirrn;
Ise
~((n~vgcrson->gerPhonenum&er()cnnp~are~t-~getPf~o~e~umbe~))
&&Grsr-child->gerPhonenmbeq)>=mtp9arenr->getPhane~t~rmber()))
f
phoneBwk.i~rsttchi1d.nctvgerson):
return;
) else
mtpgarenr =ftrst-chiid:
l*
T\vo chiidren */
eke {
if(navyerson->getPhonenwnber()>=tmpgarent->gerPhonenurnber()]
mpgcuent = second_child;
eke
mtpgarent =fitsr-chi&
1
)r+ whifeloop */
4.4 User Interface
In order to compare the selected data structures emily in STL and OrgCtr; 1 ongindly
wanted to use Micmsofi Foundation CIass (MFC) as an "application hnework" to
design and implement Windows Style User Interface for the project Because MFC is
accepted and used by many professionai programmen, it's very naturai for Windows to
have a C t t programming interface. MFC Library apptication fnmework inciudes many
genenl-purpose classes such as collection classes for tists, arrays and maps.
1 tried using MFC to design üI for both implementations in the project, but because of
dificulties with OrgCtç class genentor. 1 decided against it although a lot of time was
spent in the considention. From the perspective of the main purpose of this project. the
interface is not a criticai factor in the completion of the project to compare data structures
in STL and OrgCcç. Therefore, I used MFC Library to implement UI for "Open"
implernentation only for STL. and UI for Or@+ interactive windows under MS-DOS
was used,
4.4.1
Suspected Problems with OrgC++
The problem is that OrgC++ consists of a clss generator and a speciai Library. The class
generator typicdly just rcads the header füe with the declatations of objects and
organization, and it creates two files: an include file and a source file with ai1 the access
routines required by the program. These two fiIes are used to compile and Iink the
originai source code. Hence, when modifyuig data objects, I have to cal1 the class
generator every t h e before re-compilation. AU used classes have to be modified when
using OrgCti.; and in addition, might involve changes to the MFC base classes.
4.4.2
UI for "Open" Implementation in STL
Figure 4 below shows the main interface of the Phone Book system using STL.
Figure 4: The Main Window of PhoneBook in STL
As show m Figure 4 1can select a data structure using either doubly Linked iist or set
and dso select a number of records (nodes) to generate a phonebook
This main window also shows two resuIts:
The time used to build this phonebook in miIlisecouds
The space required to build this phonebook in bytes
In addition there are four buttons on the right side of the screen. Any one of the following
options cm be selected :
0
Semh:
to search a record of a person in the phonebook.
Insert
to insert a record of a person into the phonebook.
Remove: to delete a record of a person nom the phonebook.
Exit:
to exit the phonebook system.
The following sub-window will be popped up after pressing the Search bunon.
FIGURE
5: UI for Searching a record in STL
This sub-window aIIows us to input a phone numkr to seairh for a record of a person
whose phone number is the input phone number. It also shows the loop times when I
perform a search firnction. The seacch m 1 t will dso show in the box after 1 press the
start button.
In each sub-window 1 have three buttons to select Start, Reset and Cancel.
Staa and Reset buttons are disable in the initial sub-screen but are activated if you input a
phone number Ui the box field:
Start
to stiirt search 1 insert 1 nmove a record in / to / fiom a phonebook
Reset:
to m e t al1 data in the screen if I have done a search.
Close:
to exit this screen and go back to the main window of the application
If I press the insert button, the foUowing window is shown. It is similar to the sub-screen
of the search screen except the= are three box fields for us to input a new penonS first
nme, 1st name, and phone number into the existing phonebook.
Figure 6: UI for inserüng a record in STL
if 1press the Remove button, it will bring us to this screen:
Figure 7: UI for deleting a record in STL
It is very similar to the Search sub-screen. (See Figure 5) It also shows the remove resdt
after 1 press the Start bunon on this screen.
4.4.3
UI for "Closed" Implementation in OrgC++
1described the problems with OrgC++ in the section 4.2.1 and, therefore, only show the
interactive wÏndows for this irnplementation. See Figure 8.
Figure 8: UI in OrgC++
As we cm see, four selection options are provided I can key in the number of the
selected option and press Enter key to show the nsult Actually it is simi1ar to the four
buttons shown on the main window of the "Openttimplementation (See figure 4).
Chapter 5 Results
In this section I evaluate and analyze the performance of both implementations of data
structures considered. 1 also present the results of each experimentd test, It is important
to note that the results in this section reflect the performance of a particular
implementation of the data structures and do not uecessarily reflect performance
limitations that exist in the data structures independent of these implementations in each
.
.
Iibrary. . .
,
According -to the evduation critena defined in the section 3.1, hen 1 present the results
for each item.
-
5.1 Usability Ease of Coding
After I expenenced implementation of the data structures in both "Open" and "Closed"
implementations, 1 found both STL and OrgCtt Libmies provide sets of classes. There
are some differences.
Difference in clas declantion
In S W c m define a class just as I do in C++ to define ail data and member functions
of a clas.
In OrK*
when you declare an object (STLcalled cIass), oniy the attributes that do
not relate to the orgdation of data are declared. Objects which will be involved in
the
automatic handling of
data
mua contain a Line of the form
ZZ-EXT-<objectTypee>. This statement marks the place where the transparent
pointers will be inserted.
Here is how 1defmed a class Person in both implementations.
I
In STL
In orgctc
class PersonHasIt
class PersonHasft
f
f
public..
PersonHasIt(); // constmctor
PersonH~~l~It(Ult&
phoneMunber);
// person h a the phonenwnber.
bool operator()(Persun& operson); 1
private:
int numbec
bool operator()(Person&aPerson);
1:
a
Public:
PersonHarft(); Il construcfor
PersonHarIt(int&phoneMunber);
I/ person hm the phonenwuber.
private:
inr numbcr:
STL contains more genenc algonthms.
STL provides finci -ifl) algorithm 1 can easily use it to semh for r record in the
phonebook. Or@+
doesn\ contain this function so 1 have to define a function called
End-if() in the program. Then 1 c m use it to perfom a search as 1 would with STL. To
see the implementation of this. please refer to section 4.3, on page 23.
0
STL and 0rgC-w have very similar interface attributes.
They both have similar iteratoa and similar functions that mûnipulate the data structures
but they are not identical. In STL, data and their relations are interwoven with the classes
that carry the data. h Or@+,
data and their relations are orthogonaI.
The following shows the declaration of a phonebook in each hi-
In STL
In OrgC*
5.2 Time and Space
In this section 1 show the test results of building time ratio, access tirne ratio, and space
ratio for "Open"and "Closedrrimplernentations as 1 defmed earlier in section 3.6.3. Each
time the test results comsponding to different node numbers are genented.
Build Tirne Efficiency
The build time ratios 1 got frorn both implementations are show in Table I . From the
table, we can see that the results of build time ratio for doubly linked Iist and binary
search tree smicture are similar. They indicate that the time used to build a phonebook in
the Tlosedn implementation is greater than in the "Open" impkmentation no matter
what daîa structure is selected,
The time range of building doubly Iinked list with nodes from 8000 to 140000:
"Open1implementation:
"Closed" implementation:
- 10110 milliseconds
6040- 121390 miiliseconds
440
Table 1:
Build Time ratio
- .- .
Test
No.
1
B u ild
I
Tlm eRatio
L
I
2
3
4
5
6
7
8
9
No.of
Double
Linked L M
Node
8000
10000
20000
40000
60000
80000
100000
120000
140000
0.072848
0.044534
0,055423
0,062898
0.141 103
0,091810
0,078645
0,077346
0,083285
Build T i m e Ratio C h a r t
Access Time Efficiency
In this section, 1show the results of time ratios in the following table:
-. -.
B inary
Tree
0.088792
0,056995
.
-
Access Time Ratio
I
I
Test
No.
1
Access
Time Ratio
2
3
4
5
6
7
8
9
I
No.
of Nodes
8000
10000
20000
40000
60000
80000
100000
120000
140000
I
I
Double
Linked List
12870.400000
3555.800000
5959,500000
1 1923.500000
21 983,600000
34925.000000
29763.1 66667
35703.500000
15 1 062.000000
I
Binary
Search Tree
0.350649
0.1 82796
0.1 87500
2.941 176
0.940299
2.640884
14.060000
1 8.227273
3.638498
Access Time Ratio Chart for Double Linked List
Access Time Ratlo Chart for Binary Search Tree
I
.
From the previous section 5.2.1, we know that it tiikes more time to build a phonebook
with Tlosed" implementation. You may then wonder about access time. The test results
are surprishg as shown in TabIe 2.
The nw data, that is what I actually meûsured, is shown in Table 3.
Table 3:
Access Time
S7
list
Access
T/m
From the test results we see it quired much longer to search for a record in the
phonebook using doubly linked Iisi in the "Open" implementation. It appem that
accessing data is very efficient in the 'Closed" implementation. The results of access
time ratio for the binary search tree are very close. The "Open" implementation method
is stightly slower thm the "Closed" implementation method. Why are the results so
different? The exact cause is unclear, but it is probably due to ciifferences in the
organization of STL and OrgC++ data smictures. A11 organizations in OrgC* are based
on a riug-type arrangement, not on a NUUrtenninated List. Another possibility is that
OrgCw reorgarrizes the List so that, when a node is accessed, it becomes the first node of
the Iist. in addition, the allocation of links for STL lists may mate lot of overhead
because travershg Iists in STL requires an additional pointer jump and periodic
redIocation and copying of the Links.
5.2.3
Space Efficiency
1 show the test m l t s of space ratio in this section. From the fofiowing table 4, we can
see that the space ratios of ail the data structures 1 implemented are 15. The required
space to build a phonebook in each implementation with both selected data structures are
the same. hence, the space efficiency of the two implementations are the sane.
Table 4:
Space Ratio
I
Space
1
2
3
Ratio
4
I
No.
of Nodes
8000
10000
20000
40000
60000
80000
100000
120000
140000
test
No.
5
6
7
8
9
Double
Linked Iist
1.5
11.5
1.5
1.5
1-5
1.5
1*5
1.5
1-5
(Set)
Binaty Tree
1-5
1-5
1.5
1 -5
1-5
1.5
1.5
1-5
1-5
Space Ratio Chart
1 -c-Double Linked-List
.
-.
--
..
- .
- -- -
Binary
Tree
---- -.
From the table, it dso shows more space was recpired in the "Open" implementation than
in the "Closed" irnplementation.
5.3 Interaction with MFC
As described in section 4.4, at the beginning of design phase, 1 wanted to use MFC for
both implementations to mate UI but there are some problems with OrgCtt so 1 had to
give up using MFC for "C1osedVimplementation.
5.4 Other Cornparisons
I dso did some cornparisons of other cnteria which 1 defined in the evaluation criteria in
Chapter 3. Hem, 1 show the summarized results of cornparison on the two Librarîes in
the following table.
Table 5:
Cornparison of the two Librarles in other criteria
Compare criteria
Standard Template Library
CH Data Object Library
Is it shareware or
The standard Template L i b w It is commercial, Full source
commercial?
is one of the standardized of Data Object Libmy is
components
Are there problem to
of
the
C++ not available fkee at this
language.
time.
It's quite easy to compile.
It's not easy to compile. I
had a aot of problems to
compile on PC?
compile it on my PC at the
beginn ing.
Is it supported &y the
Yes.
No. Free binary version of
the libnry does not include
vendorf developer?
any support or guidance.
fs if a suite of tests?
No worry about instailation.
No. It took a quite of time to
It cornes with Visual C*.
install it on my PC.
Yes.
Yes
Is it easy tu crash when
It cnshed a few times when
doing a large search?
doing a large search.
Chapter 6 Conclusions
In this chapter, I conclude the experimental results and summarize the advantages of
using STL and OrgCtc; I dso discuss the research of cornparison performance of data
s m i c ~for
s fiirther directions in which the project cou1d be taken.
ui summûry, this project is an experiment of explorhg the performance of data structures
in different implementation methods. AIthough the application and data structures
selected are not considered perfect, it may provide us some interesting findings on data
structures for future research since there is not much published in this m a .
Through the project, I know the "Closed" implementation provides a new way to look at
pointer problerns. It uses a code generator to build a meta mode1 of al1 application classes
and it inserts the required pointers using generated macros, not inheritance, This is a dirty
but effîcient method which results in fûster code but is not as elegant as templates.
Compaml to the "Open" implementation method, the phonebooks are easy to implement
using templates, and they form the basis of aimost every existing container class library.
6.1 The advantages of STL and OrgC++
1 have implemented our Phonebook in both libdes, there are some daferent fwhires in
each of them:
Standard Template Librarv
Itk easy to use. It has an elegant, consistent, and easy to comprehend architecture.
The different components of
the
STL can
be plugged together which rnakes the
programmer more productive.
STL algorithms are geaenc. They work on a variety of containers and even on
ordinary C++ amys.
The use of STL is likely to make software more reliable, more portable and more
general and will reduce the cost of producing it.
It intencts weli with other libraries such as MFC*
C++Data Obiect Librarv
Data structures cm be protected against most pointer errors by initializing al1 pointers
to NULL, and setting them back to NULL when the object is disconnected fiom the
data structure, because a11 organintions arr based on a ring-type arrangement, not on
a NULL-terrninated list An object cannot be destroyed before a11 its pointers are
NULL*
It makes the data structures autornaticaily persistent by taking Code generator to find
the locations of al1 the pointers, and without the user coding and supporting
seridization functions for every clw.
It is possible to perform a f&stnin-time check for the integrity of the list.
It is more efficient sometimes to do random semch, insert or remove operations from
a doubly linked list
6.2 Future Work
There is not much work published in this area. The study of data structures in different
C* implementation methods has generally been neglected. Therefore, there is the
opportunity for much more research in this area
In this project, I presented the design and Unplementation of a phonebook system with
both '%Iosedtrand "Open'implementations in Standard Template Library and Ctç Data
Object Library. Although the implementation was for only two Libraries and for a specific
application, there are some findings recommendûtions for future work to expand the
research.
Select more libracies other thm STL and OrgCtt such as LEDA, Rogue Wave, etc.
Design and implement other applications to explore the performance of data
structures.
Select more! data structures other than doubly link lists and mes.
Implement the application on other pla~ormssuch as UNIX, Windows NT, etc.
Make cornparisons using different criteria than were used here.
Chapter 7 Bibliography
Books and articles
Joseph Bergin. Data Structure Progrmnming ivith The Standard Template Libraty
in C i + . Sp~ger-VerIagNew York Berlin, Inc, 1998
Ulrich Breymann. Designing Components with the CC+
+:A New Approach to
Progranzming. Addison-Wesley, 1998
Timothy A. Budd. Multiparadigm Programming in LEDA. Addison-Wesley
Publishing Company, Inc., 1 995
Robert Robson. Using the Sn: The C++ Standard Template Library. Spnnger-
Verlag New York, Inc., 1998
Leen Ammeraa1. Snfor C++ Programrners. John Wiley & Sons Ltd., 1997
Gndy Booch. Object Oriented Design with Applications. The BenjaminlCummings
Publishing Company,Inc., 1991
Mitchell L Model. Data Sfrttctures, Data Abstraction
-
A Contemporary
Introduction Clsing C++.Rentice Hall, hc. Englewood CIiffs, New Jersey. 1994
Glenn W . ROI. Introduction to Data S~mcturesand Afgorithrns with C++. hntice
Hdi Europe, 1997
ian Sommerville. Sofnuare Engineering. Fiifth edition Addison-WcsIey, 1995
[IO1 Cameron Hughes and Tracey Hughes. Collection and Container Classes in Ci+.
John Wiley & Sons, hc., 1996
[11] Frank M. Carrano. Data Abstraction And P r o b h Solving With C++. The
Benjamin/Cummings Publishing Company, Inc., 1995
[12] J. P. Pardoe and M.I. King. Object Oriented Programming Ushg Ci+. Macmillan
Press Ltd., 1997
B. Information on the web
[ I l Jui
Soukup.
CH
Data
Object
Libnry
and
Persistent
Data.
http:llwww.codefms.com/
[2] LEDA. hnp:!/www.m~i-sb.moede/LEDMedâ.htm1
133 Standard
Template
Library
Programmer's
http:l/wVI w .sgi .com/TechnoIogyfSTU
[4]
Standard Template Library. http:/l//www.cs.rpi.edu/-musser/stl.htmI
Guide.
Appendix
I/stlfunctor.h: nit declurution of clars Functor in SIZ, it defnes a random number
Ilgenerator. It is used to initilize a stream by a given seed.
--
Il constants used in nndom number genentor.
const unsigned long int module IOOOOOOOLU;
const unsigned long int multiplier 169874;
Ilclass Functor defines a random number genentor.
class Functor
{
Ilprivate:
unsigned long ran;
//used to represent the mdom data stream.
unsigned long random-numbem; Ildefine function random-number().
public:
// constnictor initilizes a data stream by a seed.
Functor(int i): ran(i){>
//Get a random number.
unsigned long getRandom0 { return random-nurnbea; )
//operator() overloading.
unsigned long int operator()() ( retum nadom-numbetf);)
// st1person.h: the declararion of class Person in STL. It defines a person's firstname,
Il lutname und phonenumber. C l a s ORGCPerson
class Person
{
private:
char *firstNme; //define person's fintname
char *lastNûme; ildefine person's Iastname
int phoneNumber; //define person k phonenumber
public:
Person();
il Constructor
-Person();
Il Destnictor
Person(char *f, char *1, int i-O);
cons ch@ gethmame() const { retum IastName; )
const ch& getFirsmme() const { ceturn fmtName; )
If void setLastname(l);
l/ void setFinmame(f)
Il void setPhonenumber(i);
int sizeo;
int getPhonenumber()const;
// Get a person's phonenurnber.
void setPerson(char *s 1, char *s2, int i d ) ; // Set a person's record.
//operators
friend ostrearn& operator<<(ostnam&out, cons Person& p);
bool operator-(const Person& p2);
bool operator!-(const Person& p2);
bool operator<(const Person& p2);
bool operato~(constPerson& pz);
class PersonLess
.(
public:
bool operator0 (const Person& x, const Person& y) const (
-
#ifdef ND-NAME
int temp strcmp(x.getLastname0. y.getL.ashiame0);
if(tempc0)
return tme;
else if (temp > O)
nturn fiilse;
-
temp strcmp(x.getFitname(), y.getFmtnme0);
if(tempC0)
retum tme;
else retum false;
#else
retum x.getPhonenumber() < y.getE%onenumber();
#endif
}
k
Il st1personhasit.h: contains dedarution of class ORGCPersonHasIt in OrgC++. It
II dejhes thefinetion that is used to get a person's record by a given phonenumber.
class PersonHasIt
{
public:
PersonHasItO; 11 constnictor
PersonHasIt(int& phoneNumber); // person has the phonenumber.
bool operator() (Person& aPerson);
private:
int number;
1;
II orgcjùnctor.hi The dedaration of class class Functor in Orge++, it defines a random
Il ntaber generator. It is used to initilize a Stream by a given seed.
Il constants used in random number generator.
const unsigned long int module = 10000000LU;
const unsigned long int multiplier 169874;
-
Ilclass Functor defines a random number generator.
c1;tss Functor
{
ZZ_EXT_Functor
Ilprivate:
unsigned long ran; Ilused to represent the random data Stream.
unsigned Iong random-number(); //define function mdom-number().
public:
Il coastructor initilizes a &ta Stream by a seed.
Functor(int i): m(i){
>
IiGet a random number,
unsigned long getR;uidom() ( return random-nurnbem; )
Ilopentor() overloading.
unsigned Iong int operator()() ( retum random-number();)
Ilorgcperson.h: the dedaration of class Person in O@+
If firstnume, l a s t m e and phonenumber.
+. It defines a person's
#indude ciostreamb
#indude "zzinc 1.h"
class PersonhasIt;
ciass Person
fnend int phoneBooksize();
Fnend Person* findif(PersonHasIt& another-person);
pnvate:
char *firstNme; Ildefine person 's fmtname
char *lasName; //define person's iastnme
int phoneNumber, Ildefine person's phonenumber
public:
Person();
// Constructor
-Person();
// Destructor
Person(char *f, char *I, int i-O);
const char* getLastname() const { cemm IastName; )
const char* getFirstname0 const { r e m fhtName; )
int GetSizeo;
Il Get a person's phonenumber.
int getPhonenurnber() const;
void setPerson(char *SI, char *s2. int i d ) ; // Set a person's record.
Iloperators
friend ostream& operator<c(ostmm& out*const Person& p);
bool operator-(const Person& p2);
bool opcrator!-(const Person& p2);
bool operator<(cwst Person& pz);
bool operato~constPerson& p2);
public:
bool operator0 (const PersonBr x, const PersonBr y) const {
-
#ifdef IND-NAME
int temp strcmp(x.getLastname0, y.getlastname());
if ( temp < 0)
return tme;
return fdse;
else if (temp > O)
-
temp strcmp(x.ge~mtname(),y.ge@mtname());
if ( temp < 0)
retum me;
else return false;
#else
cetum x.getPhonenumber() < y.getPhonenumber();
#endif
}
1;
II orgcpersonhasit.h: contains deciaralion of class ORGCPersonHasIt in Or&++. Zt
II deftnes thejùnction t h t is used to get a person's record &y a given phonenumber.
public:
PersonHask(); // constructor
PersonHasit(int& phoneNumber); Il person has the phonenumber.
bool operator() (Person& aPerson);
private:
int number;
k
Il defme phonenumber as integer.