name must have external visibility, the type representation must be hidden. The type representation and the definitions of the subprograms that implement the operations may appear inside or outside this syntactic unit.

Few, if any, general built-in operations should be provided for objects of abstract data types, other than those provided with the type definition. There simply are not many operations that apply to a broad range of abstract data types. Among these are assignment and comparisons for equality and inequality. If the language does not allow users to overload assignment, the assignment operation must be included in the abstraction. Comparisons for equality and inequality should be predefined in the abstraction in some cases but not in others. For example, if the type is implemented as a pointer, equality may mean pointer equality, but the designer may want it to mean equality of the structures referenced by the pointers.

Some operations are required by many abstract data types, but because they are not universal, they often must be provided by the designer of the type. Among these are iterators, accessors, constructors, and destructors. Iterators were discussed in Chapter 8. Accessors provide a form of access to data that is hidden from direct access by clients. Constructors are used to initialize parts of newly created objects. Destructors are often used to reclaim heap storage that may be used by parts of abstract data type objects in languages that do not do implicit storage reclamation.

As stated earlier, the enclosure for an abstract data type defines a single data type and its operations. Many contemporary languages, including C++, Objective-C, Java, and C#, directly support abstract data types. One alternative approach is to provide a more generalized encapsulation construct that can define any number of entities, any of which can be selectively specified to be visible outside the enclosing unit. Ada uses this approach. These enclosures are not abstract data types but rather are generalizations of abstract data types. As such, they can be used to define abstract data types. Although we discuss Ada’s encapsulation construct in this section, we treat it as a minimal encapsulation for single data types. Generalized encapsulations are the topic of Section 11.6.

So, the first design issue for abstract data types is the form of the container for the interface to the type. The second design issue is whether abstract data types can be parameterized. For example, if the language supports parameterized abstract data types, one could design an abstract data type for some structure that could store elements of any type. Parameterized abstract data types are discussed in Section 11.5. The third design issue is what access controls are provided and how such controls are specified. Finally, the language designer must decide whether the specification of the type is physically separate from its implementation (or whether that is a developer choice).

11.4 Language Examples

The concept of data abstraction had its origins in SIMULA 67, although that language did not provide complete support for abstract data types, because it did not include a way to hide implementation details. In this section, we describe the support for data abstraction provided by Ada, C++, Objective-C, Java, C#, and Ruby.

11.4.1Abstract Data Types in Ada

Ada provides an encapsulation construct that can be used to define a single abstract data type, including the ability to hide its representation. Ada 83 was one of the first languages to offer full support for abstract data types.

11.4.1.1 Encapsulation

The encapsulating constructs in Ada are called packages. A package can have two parts, each of which is also is called a package. These are called the package specification, which provides the interface of the encapsulation (and perhaps more), and the body package, which provides the implementation of most, if not all, of the entities named in the associated package specification. Not all packages have a body part (packages that encapsulate only types and constants do not have or need bodies).

A package specification and its associated body package share the same name. The reserved word body in a package header identifies it as being a body package. A package specification and its body package may be compiled separately, provided the package specification is compiled first. Client code can also be compiled before the body package is compiled or even written, for that matter. This means that once the package specification is written, work can begin on both the client code and the body package.

11.4.1.2 Information Hiding

The designer of an Ada package that defines a data type can choose to make the type entirely visible to clients or provide only the interface information. Of course, if the representation is not hidden, then the defined type is not an abstract data type. There are two approaches to hiding the representation from clients in the package specification. One is to include two sections in the package specification—one in which entities are visible to clients and one that hides its contents. For an abstract data type, a declaration appears in the visible part of the specification, providing only the name of the type and the fact that its representation is hidden. The representation of the type appears in a part of the specification called the private part, which is introduced by the reserved word private. The private clause is always at the end of the package specification. The private clause is visible to the compiler but not to client program units.

The second way to hide the representation is to define the abstract data type as a pointer and provide the pointed-to structure’s definition in the body package, whose entire contents are hidden from clients.

Types that are declared to be private are called private types. Private data types have built-in operations for assignment and comparisons for equality and inequality. Any other operation must be declared in the package specification that defined the type.

The reason that a type’s representation appears in the package specification at all has to do with compilation issues. Client code can see only the package

specification (not the body package), but the compiler must be able to allocate objects of the exported type when compiling the client. Furthermore, the client is compilable when only the package specification for the abstract data type has been compiled and is present. Therefore, the compiler must be able to determine the size of an object from the package specification. So, the representation of the type must be visible to the compiler but not to the client code. This is exactly the situation specified by the private clause in a package specification.

An alternative to private types is a more restricted form: limited private types. Nonpointer limited private types are described in the private section of a package specification, as are nonpointer private types. The only syntactic difference is that limited private types are declared to be limited private in the visible part of the package specification. The semantic difference is that objects of a type that is declared limited private have no built-in operations. Such a type is useful when the usual predefined operations of assignment and comparison are not meaningful or useful. For example, assignment and comparison are rarely used for stacks.

11.4.1.3 An Example

The following is the package specification for a stack abstract data type:

package Stack_Pack is

-- The visible entities, or public interface type Stack_Type is limited private; Max_Size : constant := 100;

function Empty(Stk : in Stack_Type) return Boolean; procedure Push(Stk : in out Stack_Type;

Element : in Integer); procedure Pop(Stk : in out Stack_Type);

function Top(Stk : in Stack_Type) return Integer; -- The part that is hidden from clients

private

type List_Type is array (1..Max_Size) of Integer; type Stack_Type is

record

List : List_Type;

Topsub : Integer range 0..Max_Size := 0; end record;

end Stack_Pack;

Notice that no create or destroy operations are included, because they are not necessary.

The body package for Stack_Pack is as follows:

with Ada.Text_IO; use Ada.Text_IO;

package body Stack_Pack is

function Empty(Stk: in Stack_Type) return Boolean is

begin

return Stk.Topsub = 0;

end Empty;

procedure Push(Stk : in out Stack_Type; Element : in Integer) is

begin

if Stk.Topsub >= Max_Size then

Put_Line("ERROR - Stack overflow");

else

Stk.Topsub := Stk.Topsub + 1;

Stk.List(Topsub) := Element;

end if;

end Push;

procedure Pop(Stk : in out Stack_Type) is

begin

if Empty(Stk)

then Put_Line("ERROR - Stack underflow"); else Stk.Topsub := Stk.Topsub - 1;

end if; end Pop;

function Top(Stk : in Stack_Type) return Integer is begin

if Empty(Stk)

then Put_Line("ERROR - Stack is empty"); else return Stk.List(Stk.Topsub);

end if;

end Top;

end Stack_Pack;

The first line of the code of this body package contains two clauses: a with and a use. The with clause makes the names defined in external packages visible; in this case Ada.Text_IO, which provides functions for input and output of text. The use clause eliminates the need for explicit qualification of the references to entities from the named package. The issues of access to external encapsulations and name qualifications are further discussed in Section 11.7.

The body package must have subprogram definitions with headings that match the subprogram headings in the associated package specification. The package specification promises that these subprograms will be defined in the associated body package.

The following procedure, Use_Stacks, is a client of package Stack_Pack. It illustrates how the package might be used.

11.4.2.3 Constructors and Destructors

C++ allows the user to include constructor functions in class definitions, which are used to initialize the data members of newly created objects. A constructor may also allocate the heap-dynamic data that are referenced by the pointer members of the new object. Constructors are implicitly called when an object of the class type is created. A constructor has the same name as the class whose objects it initializes. Constructors can be overloaded, but of course each constructor of a class must have a unique parameter profile.

A C++ class can also include a function called a destructor, which is implicitly called when the lifetime of an instance of the class ends. As stated earlier, stack-dynamic class instances can contain pointer members that reference heap-dynamic data. The destructor function for such an instance can include a delete operator on the pointer members to deallocate the heap space they reference. Destructors are often used as a debugging aid, in which case they simply display or print the values of some or all of the object’s data members before those members are deallocated. The name of a destructor is the class’s name, preceded by a tilde (~).

Neither constructors nor destructors have return types, and neither use return statements. Both constructors and destructors can be explicitly called.

11.4.2.4 An Example

Our examle of a C++ abstract data type is, once again, a stack:

#include <iostream.h> class Stack {

private: //** These members are visible only to other //** members and friends (see Section 11.6.4)

int *stackPtr; int maxLen; int topSub;

public: //** These members are visible to clients Stack() { //** A constructor

stackPtr = new int [100]; maxLen = 99;

topSub = -1;

}

~Stack() {delete [] stackPtr;}; //** A destructor void push(int number) {

if (topSub == maxLen)

cerr << "Error in push--stack is full\n"; else stackPtr[++topSub] = number;

}

void pop() { if (empty())

488 Chapter 11 Abstract Data Types and Encapsulation Constructs

cerr << "Error in pop--stack is empty\n"; else topSub--;

}

int top() { if (empty())

cerr << "Error in top--stack is empty\n";

else

return (stackPtr[topSub]);

}

int empty() {return (topSub == -1);}

}

We discuss only a few aspects of this class definition, because it is not necessary to understand all of the details of the code. Objects of the Stack class are stack dynamic but include a pointer that references heap-dynamic data. The Stack class has three data members—stackPtr, maxLen, and topSub—all of which are private. stackPtr is used to reference the heap-dynamic data, which is the array that implements the stack. The class also has four public member functions—push, pop, top, and empty—as well as a constructor and a destructor. All of the member function definitions are included in this class, although they could have been externally defined. Because the bodies of the member functions are included, they are all implicitly inlined. The constructor uses the new operator to allocate an array of 100 int elements from the heap. It also initializes maxLen and topSub.

The following is an example program that uses the Stack abstract data type:

void main() { int topOne;

Stack stk; //** Create an instance of the Stack class stk.push(42);

stk.push(17); topOne = stk.top(); stk.pop();

...

}

Following is a definition of the Stack class with only prototypes of the member functions. This code is stored in a header file with the .h file name extension. The definitions of the member functions follow the class definition. These use the scope resolution operator, ::, to indicate the class to which they belong. These definitions are stored in a code file with the file name extension .cpp.

// Stack.h - the header file for the Stack class #include <iostream.h>

class Stack {

private: //** These members are visible only to other //** members and friends (see Section 11.6.4)

int *stackPtr; int maxLen; int topSub;

public: //** These members are visible to clients Stack(); //** A constructor

~Stack(); //** A destructor void push(int);

void pop(); int top(); int empty();

}

// Stack.cpp - the implementation file for the Stack class #include <iostream.h>

#include "Stack.h" using std::cout;

Stack::Stack() { //** A constructor stackPtr = new int [100];

maxLen = 99; topSub = -1;

}

Stack::~Stack() {delete [] stackPtr;}; //** A destructor

void Stack::push(int number) { if (topSub == maxLen)

cerr << "Error in push--stack is full\n"; else stackPtr[++topSub] = number;

}

void Stack::pop() { if (topSub == -1)

cerr << "Error in pop--stack is empty\n"; else topSub--;

}

int top() {

if (topSub == -1)

cerr << "Error in top--stack is empty\n";

else

return (stackPtr[topSub]);

}

int Stack::empty() {return (topSub == -1);}

11.4.2.5 Evaluation

C++ support for abstract data types, through its class construct, is similar in expressive power to that of Ada, through its packages. Both provide effective mechanisms for encapsulation and information hiding of abstract data types. The primary difference is that classes are types, whereas Ada packages are more general encapsulations. Furthermore, the package construct of Ada was designed for more than data abstraction, as discussed in Chapter 12.

11.4.3Abstract Data Types in Objective-C

As has been previously stated, Objective-C is similar to C++ in that its initial design was the C language with extensions to support object-oriented programming. One of the fundamental differences between the two is that Objective-C uses the syntax of Smalltalk for its method calls.

11.4.3.1 Encapsulation

The interface part of an Objective-C class is defined in a container called an interface with the following general syntax:

@interface class-name: parent-class { instance variable declarations

}

method prototypes

@end

The first and last lines, which begin with at signs (@), are directives.

The implementation of a class is packaged in a container naturally named implementation, which has the following syntax:

@implementation class-name method definitions

@end

As in C++, in Objective-C classes are types.

Method prototypes have the following syntax:

(+ | -)(return-type) method-name [: (formal-parameters)];

When present, the plus sign indicates that the method is a class method; a minus sign indicates an instance method. The brackets around the formal parameters indicate that they are optional. Neither the parentheses nor the colon are present when there are no parameters. As in most other languages that support object-oriented programming, all instances of an Objective-C class share a single copy of its instance methods, but each instance has its own copy of the instance data.

Constructors in Objective-C are called initializers; they only provide initial values. They can be given any name, and as a result they must be explicitly called. Constructors return a reference to the new object, so their type is always a pointer to the class-name. They use a return statement that returns self, a reference to the current object.

An object is created in Objective-C by calling alloc. Typically, after calling alloc, the constructor of the class is explicitly called. These two calls can be and usually are cascaded, as in the following statement, which creates an object of Adder class with alloc and then calls its constructor, init, on the new object, and puts the address of the new object in myAdder:

Adder *myAdder = [[Adder alloc]init];

All class instances are heap dynamic and are referenced through reference variables.

C programs nearly always import a header file for input and output functions, stdio.h. In Objective-C, a header file is usually imported that has the prototypes of a variety of often required functions, including those for input and output, as well as some needed data. This is done with the following:

#import <Foundation/Foundation.h>

Importing the Foundation.h header file creates some data for the program. So, the first thing the main function should do is allocate and initialize a pool of storage for this data. This is done with the following statement:

NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

Just before the return statement in main, this pool is released with a call to the drain method of the pool object, as in the following statement:

[pool drain];

11.4.3.2 Information Hiding

Objective-C uses the directives, @private and @public, to specify the access levels of the instance variables in a class definition. These are used as the reserved words public and private are used in C++. The difference is that the default in Objective-C is protected, whereas it is private in C++. Unlike most programming languages that support object-oriented programming, in Objective-C there is no way to restrict access to a method.

In Objective-C, the convention is that the name of a getter method for an instance variable is the variable’s name. The name of the setter method is the word set with the capitalized variable’s name attached. So, for a variable named sum, the getter method would be named sum and the setter method

494Chapter 11 Abstract Data Types and Encapsulation Constructs

//stack.m - interface and implementation of a simple stack

#import <Foundation/Foundation.h>

//Interface section

@interface Stack: NSObject { int stackArray [100];

int stackPtr; int maxLen; int topSub;

}

-(void) push: (int) number; -(void) pop;

-(int) top; -(int) empty;

@end

// Implementation section

@implementation Stack -(Stack *) initWith {

maxLen = 100; topSub = -1;

stackPtr = stackArray; return self;

}

-(void) push: (int) number { if (topSub == maxLen)

NSLog(@"Error in push--stack is full"); else

stackPtr[++topSub] = number;

}

-(void) pop {

if (topSub == -1)

NSLog(@"Error in pop--stack is empty"); else

topSub--;

}

-(int) top {

if (topSub >= 0)

return stackPtr[topSub]);

else

NSLog(@"Error in top--stack is empty");

class he or she defines. Such constructors can assign initial values to some or all of the instance data of the class. Any instance variable that is not initialized in a user-defined constructor is assigned a value by the default constructor.

Although C# allows destructors to be defined, because it uses garbage collection for most of its heap objects, destructors are rarely used.

11.4.5.1 Encapsulation

As mentioned in Section 11.4.2, C++ includes both classes and structs, which are nearly identical constructs. The only difference is that the default access modifier for class is private, whereas for structs it is public. C# also has structs, but they are very different from those of C++. In C#, structs are, in a sense, lightweight classes. They can have constructors, properties, methods, and data fields and can implement interfaces but do not support inheritance. One other important difference between structs and classes in C# is that structs are value types, as opposed to reference types. They are allocated on the runtime stack, rather than the heap. If they are passed as parameters, like other value types, by default they are passed by value. All C# value types, including all of its primitive types, are actually structs. Structs can be created by declaring them, like other predefined value types, such as int or float. They can also be created with the new operator, which calls a constructor to initialize them.

Structs are used in C# primarily to implement relatively small simple types that need never be base types for inheritance. They are also used when it is convenient for the objects of the type to be stack as opposed to heap allocated.

11.4.5.2 Information Hiding

C# uses the private and protected access modifiers exactly as they are used in Java.

C# provides properties, which it inherited from Delphi, as a way of implementing getters and setters without requiring explicit method calls by the client. As with Objective-C, properties provide implicit access to specific private instance data. For example, consider the following simple class and client code:

public class Weather {

public int DegreeDays { //** DegreeDays is a property get {

return degreeDays;

}

set {

if(value < 0 || value > 30) Console.WriteLine(

"Value is out of range: {0}", value);

else

degreeDays = value;

}

}

private int degreeDays;

...

}

...

Weather w = new Weather();

int degreeDaysToday, oldDegreeDays;

...

w.DegreeDays = degreeDaysToday;

...

oldDegreeDays = w.DegreeDays;

In the class Weather, the property DegreeDays is defined. This property provides a getter method and a setter method for access to the private data member, degreeDays. In the client code following the class definition, degreeDays is treated as if it were a public-member variable, although access to it is available through the property only. Notice the use of the implicit variable value in the setter method. This is the mechanism by which the new value of the property is referenced.

The stack example is not shown here in C#. The only difference between the Java version in Section 11.4.4.1 and the C# version is the output method calls and the use of bool instead of boolean for the return type of the empty method.

11.4.6Abstract Data Types in Ruby

Ruby provides support for abstract data types through its classes. In terms of capabilities, Ruby classes are similar to those in C++ and Java.

11.4.6.1 Encapsulation

In Ruby, a class is defined in a compound statement opened with the class reserved word and closed with end. The names of instance variables have

aspecial syntactic formthey must begin with at signs (@). Instance methods have the same syntax as functions in Ruby: They begin with the def reserved word and end with end. Class methods are distinguished from instance methods by having the class name appended to the beginning of their names with a period separator. For example, in a class named Stack,

aclass method’s name would begin with Stack. Constructors in Ruby are named initialize. Because the constructor cannot be overloaded, there only can be one per class.

Classes in Ruby are dynamic in the sense that members can be added at any time. This is done by simply including additional class definitions that specify the new members. Moreover, even predefined classes of the language, such as String, can be extended. For example, consider the following class definition:

class myClass

def meth1

...

end

end

This class could be extended by adding a second method, meth2, with a second class definition:

class myClass

def meth2

...

end

end

Methods can also be removed from a class. This is done by providing another class definition in which the method to be removed is sent to the method remove_method as a parameter. The dynamic classes of Ruby are another example of a language designer trading readability (and as a consequence, reliability) for flexibility. Allowing dynamic changes to classes clearly adds flexibility to the language, while harming readability. To determine the behavior of a class at a particular point in a program, one must find all of its definitions in the program and consider all of them.

11.4.6.2 Information Hiding

Access control for methods in Ruby is dynamic, so access violations are detected only during execution. The default method access is public, but it can also be protected or private. There are two ways to specify the access control, both of which use functions with the same names as the access levels, private and public. One way is to call the appropriate function without parameters. This resets the default access for subsequently defined methods in the class. For example,

class MyClass

def meth1

...

end

...

private

def meth7

...

end

...

end # of class MyClass

The alternative is to call the access control functions with the names of the specific methods as parameters. For example, the following is semantically equivalent to the previous class definition:

class MyClass def meth1

...

end

...

def meth7

...

end

private :meth7, ...

end # of class MyClass

In Ruby, all data members of a class are private, and that cannot be changed. So, data members can be accessed only by the methods of the class, some of which may be accessor methods. In Ruby, instance data that are accessible through accessor methods are called attributes.

For an instance variable named @sum, the getter and setter methods would be as follows:

def sum

@sum

end

def sum=(new_sum)

@sum = new_sum

end

Notice that getters are given the name of the instance variable minus the @. The names of setter methods are the same as those of the corresponding getters, except they have an equal sign (=) attached.

Getters and setters can be implicitly generated by the Ruby system by including calls to attr_reader and attr_writer, respectively, in the class definition. The parameters to these are the symbols of the attribute’s names, as is illustrated in the following:

attr_reader :sum, :total

attr_writer :sum

11.4.6.3 An Example

Following is the stack example written in Ruby:

#Stack.rb - defines and tests a stack of maximum length

#100, implemented in an array

class StackClass

#Constructor def initialize

@stackRef = Array.new(100) @maxLen = 100

@topIndex = -1 end

#push method

def push(number)

if @topIndex == @maxLen

puts "Error in push - stack is full" else

@topIndex = @topIndex + 1 @stackRef[@topIndex] = number

end end

#pop method def pop

if empty

puts "Error in pop - stack is empty" else

@topIndex = @topIndex - 1 end

end

#top method def top

if empty

puts "Error in top - stack is empty" else

@stackRef[@topIndex] end

end

#empty method def empty

@topIndex == -1

end

end # of Stack class

# Test code for StackClass myStack = StackClass.new myStack.push(42)