2.2.

1 Constructors and destructors

The create and destroy methods - often called constructors and destructors - are
usually implemented
for any abstract data type. Occasionally, the data type's use or semantics are
such that there is only
ever one object of that type in a program. In that case, it is possible to hide even
the object's `handle'
http://ciips.ee.uwa.edu.au/~morris/Year2/PLDS210/objects.html (1 of 4) [3/23/2004 2:24:14 PM]
Data Structures and Algorithms: Objects and ADTs
from the user. However, even in these cases, constructor and destructor methods
are often provided.
Of course, specific applications may call for additional methods, e.g. we may
need to join two
collections (form a union in set terminology) - or may not need all of these.
One of the aims of good program design would be to ensure that additional
requirements
are easily handled.
2.2.2 Data Structure
To construct an abstract software model of a collection, we start by building the
formal specification.
The first component of this is the name of a data type - this is the type of objects
that belong to the
collection class. In C, we use typedef to define a new type which is a
pointer to a structure:
typedef struct collection_struct *collection;
Note that we are defining a pointer to a structure only; we have not specified
details of the attributes
of the structure. We are deliberately deferring this - the details of the
implementation are irrelevant at
this stage. We are only concerned with the abstract behaviour of the collection.
In fact, as we will see
later, we want to be able to substitute different data structures for the actual
implementation of the
collection, depending on our needs.
The typedef declaration provides us with a C type (class in OO design
parlance), collection.
We can declare objects of type collection wherever needed. Although C
forces us to reveal that
the handle for objects of the class is a pointer, it is better to take an abstract
view: we regard variables
of type collection simply as handles to objects of the class and forget that
the variables are
actually C pointers.
2.2.3 Methods
Next, we need to define the methods:
collection ConsCollection( int max_items, int
item_size );
void AddToCollection( collection c, void *item );
void DeleteFromCollection( collection c, void *item
);
void *FindInCollection( collection c, void *key );
Note that we are using a number of C "hacks" here. C - even in ANSI standard
form - is not exactly
the safest programming language in the sense of the support it provides for the
engineering of quality
software. However, its portability and extreme popularity mean that it is a
practical choice for even
large software engineering projects. Unfortunately, C++, because it is based on
C, isn't much better.
Java, the latest fad in the software industry, shows some evidence that its
designers have learned from
experience (or actually read some of the literature in programming language
research!) and has
eliminated some of the more dangerous features of C.
http://ciips.ee.uwa.edu.au/~morris/Year2/PLDS210/objects.html (2 of 4) [3/23/2004 2:24:14 PM]
Data Structures and Algorithms: Objects and ADTs
Just as we defined our collection object as a pointer to a structure, we assume
that the object which
belong in this collection are themselves represented by pointers to data
structures. Hence in
AddToCollection, item is typed void *. In ANSI C, void * will
match any pointer - thus
AddToCollection may be used to add any object to our collection.
Similarly, key in
FindInCollection is typed void *, as the key which is used to find any
item in the collection
may itself be some object. FindInCollection returns a pointer to the item
which matches key, so
it also has the type void *. The use of void * here highlights one of the
deficiencies of C: it
doesn't provide the capability to create generic objects, cf the ability to define
generic packages in Ada
or templates in C++.
Note there are various other "hacks" to overcome C's limitations in this area.
One uses the preprocessor.
You might like to try to work out an alternative approach and try to convince
your tutor that
it's better than the one set out here!