The authors introduce a simple yet powerful extension to C++ for abstracting types and decoupling subtyping and inheritance. They argue that the current dual purpose of the C++ class construct--to define and implement a type, and to serve as the basis for inheritance, type abstraction, and subtype polymorphism--limits programmer flexibility when using dynamic typing. The signature extension is proposed as a mechanism for allowing type and class hierarchies to be structured independently, thereby increasing the flexibility of dynamic typing “without sacrificing the efficiency and security of static typing.”

Signature declarations are used to define abstract types by specifying the member functions that any implementation of the type must have. Implementations may be associated with signatures by signature pointers. Whenever an object pointer is assigned to a signature pointer, the compiler verifies that the object’s class structurally conforms to the signature. Whenever signature member functions are called, the appropriate class member function is invoked.

The paper begins by discussing two problems arising from the use of inheritance as a subtyping mechanism: difficulties in retroactively introducing an abstract base class to an existing class hierarchy, and difficulties in reconciling abstract type hierarchies with the class hierarchies of an implementation. Next, the signature construct is introduced and illustrated.

Detailed descriptions of three techniques for implementing signatures follow. The first two--using a preprocessor and using a compiler front-end implementation--focus on encapsulating class objects with generated interface objects. Detailed outlines of these implementations, with examples, are provided. The third implementation uses back-end support from the compiler. The performance of all three proposed implementations is presented in terms of words of memory and logical operation requirements.

The problems associated with the dual requirements for the class construct in C++ are shown clearly. Using signatures and signature conformance, subtyping and inheritance are separated semantically and their implementations are decoupled. Finally, the authors note similarities and differences between signatures and related constructs in other languages--interfaces in Java, type modules in Trellis/Owl, modules in Modula-2, and interfaces in Modula-3.