Code Capsules

Chuck Allison is a regular columnist with CUJ and a Senior Software Engineer in the Information and Communication Systems Department of the Church of Jesus Christ of Latter Day Saints in Salt Lake City. He has a B.S. and M.S. in mathematics, has been programming since 1975, and has been teaching and developing in C since 1984. His current interest is object-oriented technology and education. He is a member of X3J16, the ANSI C++ Standards Committee. Chuck can be reached on the Internet at [email protected].

You may be tired of hearing it, but let me say it one last time: you can view C++ in three ways: 1) as a better C, 2) as a language that supports data abstraction, and 3) as a vehicle for object-oriented programming. In last month's article I explored the "better C" features of C++. This month I'll show how it supports data abstraction, or, in other words, how it helps you create new data types.

Abstraction

"An abstraction denotes the essential characteristics of an object that distinguish it from all other kinds of objects and thus provide crisply-defined conceptual boundaries, relative to the perspective of the viewer." [1]

Abstraction often manifests itself in software through user-defined data types, new classes of objects composed of built-in or other user-defined types. This concept is not new, of course, but languages that support it well, such as Ada, C++, CLOS, and Smalltalk, have only recently seen widespread use.

If you've been programming in C for any length of time, you've probably used the struct mechanism. You've also had to provide functions to process those structures. Whether you knew it or not, you were creating a user-defined type. Chances are, for example, you've needed to handle dates in a program. Listing 1 defines a struct Date and two functions for processing dates, one to format a date as Month Day, Year, and one to compare dates. (See Listing 2 for the functions' implementation and Listing 3 for a test program.)

To use this abstract data type, you only need to know the protocol for its two functions, which constitute its interface. You don't need to know how the functions were implemented, or even the structure layout. A well-defined abstraction enables concentration on the outside view while ignoring implementation details. This barrier between interface and implementation is called encapsulation. There is a hole in type Date's encapsulation barrier, of course, because it's possible to bypass the interface and directly manipulate one of the structure members, as in

   dp->month = 7;

C++ improves support for user-defined data types in at least two ways: 1) by allowing definition of the interface functions within the scope of the class, and 2) by barring client access to implementation details via a language keyword, as opposed to the incomplete type trick. The Date class in Listing 7 and Listing 8 differs from that in Listing 1 and Listing 2 in the following ways:

1) The data members are private, so client programs can't access them directly (only the member functions can).

2) The interface functions are public member functions, so they can only apply to Date objects, and the function names do not pollute the global namespace. The date_ prefix is no longer necessary, since the operations belong to the class. Note that format and compare are const member functions, meaning that they promise not to alter a Date's data members.

3) A constructor replaces C's structure initialization syntax.

4) The text representations for the month names now appear in the scope of struct Date (being static members).

The sample program in Listing 9 shows that member functions are invoked with the usual dot operator for structure members.

If it bothers you that a client programmer can still see the layout of your data members — albeit without direct access — you can hide the data member declarations in a new incomplete type, but this time with absolutely no impact to the interface (see Listing 10 and Listing 11) . To demonstrate this, I define the DateRep helper class with a constructor, and for efficiency and simplicity I give the Date class direct access to the its data members by making it a friend to DateRep. The Date constructor now needs to create its associated DateRep object on the heap, so a destructor is needed to free the heap memory. Only the header file has to change in the test program in Listing 9. With a well-defined abstraction, a change in implementation will not inflict change on client code.

Operator Overloading

As the definition of the Person class in Listing 16 shows, you can compose a new type from other user-defined types, as well as built-in types. Each Person has a birth date, which is a Date object wholly contained within a Person object. The Person constructor passes the Date information on to its Date subobject via an initialization list. The initialization list follows the colon in the function header, as defined in the implementation file (Listing 17) . Notice how Person::operator<< implicitly uses Date::operator<<. Class Person also uses the new C++ standard string class for its text data members. (Borland C++, the compiler I used for most of these examples, defines the string class in the header (cstring.h>).

Concrete Data Types

copy constructor
default constructor (and others as needed)
assignment operator
destructor

Whenever an object is created, a constructor is called to initialize it. The initializer arguments must match a constructor's parameters in number and type. The default constructor is the one that takes no arguments. Another special constructor, called the copy constructor, initializes a new object from an existing object of the same type, and has the signature T(const T&), or T(T&), for some type T. This constructor executes whenever you pass or return an object by value, or explicitly initialize a new object from an old one, as with y in the following example:

   T x;
   ...
   T y = x;     // same as "T y(x)"

   T& T::operator=(const T&)

   Person& Person::operator=(const Person& p)
   {
      last = p.last;
      first = p.first;
      birth = p.birth;
      ssn = p.ssn;
      return *this;
   }

   Person::Person(const Person& p)
     : last(p.last), first(p.first), birth(p.birth),
       ssn(p.ssn)
   {}

If you define any constructor other than a copy constructor, then the compiler will not generate a default constructor for you. If you don't define any constructors (other than copy constructors) the compiler will generate a default constructor which will invoke the corresponding default constructor for all user-defined member objects. A compiler-generated destructor calls the destructors associated with any user-defined member objects.

The compiler-generated assignment operator and copy constructor for Person worked because the standard string class provides its own version of these two functions, and because the Data class data members are built-in, so its compiler-generated constructors and operators suffice. In general, whenever the state of an object is contained entirely within the object itself, you do not need to override the compiler-generated member functions.

The Person class in Listing 19 and Listing 20 stores its text data on the heap. A compiler-generated assignment operator or copy constructor will only copy pointers to the receiving object, when what it really needs to do is allocate space on the heap for the duplicated text. When I execute the test program on this class, Metaware's C++ gives the following output on Windows NT:

p1 == {Richardson,Alice,[December 16, 1947], 123-45-6789}
p2 == {Doe,John,[Bad month 0, 0],}
p1 does not equal p2
p3 does equal p2
***Free(0X4C105C):X POINTER already free
ABORTING. . .

Generic Types

C++'s template mechanism allows you to define a generic set type that essentially ignores the type of the objects it contains, by specifying that type as a parameter (see Listing 26) . For efficiency, I use the dynamically-sized vector template class from the Standard C++ library in the implementation. Dynamic sizing is crucial when using a set of large objects, since a fixed-size array of the same would result in much wasted space. As you can see in set2.h in Listing 26, the find algorithm also works on vectors. This is because its begin and end member functions return an iterator, which is a generalization of a pointer. The erase member function expects an iterator argument, which find returns. The program in Listing 27 uses the Set template to hold Person objects.

Summary

Computers In Kansas

I've also enjoyed contributing as a columnist for this journal since October 1992. This has been a valuable outlet for me to share some of my learnings as a C/C++ developer and contributor to the C++ standard. Due to personal time constraints, I reluctantly announce that this is my last column. I've appreciated your feedback and support, and will miss you and the folks at R&D. Goodbye, farewell, and keep on hacking.

Reference