Signatures: A language extension for improving type abstraction and subtype polymorphism in C++

Baumgartner, Gerald; Russo, Vincent M.

doi:10.1002/spe.4380250803

Cited by 20 publications

(10 citation statements)

References 21 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…We took the term type abstraction from [3], but the concept is also known as data abstraction, as described by Liskov in [13]. The latter paper is also the reason why we distinguish type abstraction from type hierarchies: the paper argues quite convincingly that the "implements" relation should be distinguished from the "is a" relation.…”

Section: Type Abstractionmentioning

confidence: 96%

Teaching inheritance concepts with Java

Schmolitzky

2006

Proceedings of the 4th International Symposium on Principles and Practice of Programming in Java - PPPJ '06

View full text Add to dashboard Cite

In teaching object-oriented programming, teaching inheritance is the most challenging and at the same time the most crucial aspect. The interplay of dynamic binding, late-bound self-reference, subtype polymorphism and method redefinition is so complex that it is difficult for instructors to design a gentle, step-by-step introduction. Should polymorphism be introduced first? Or is code reuse better suited as an introductory motivation? The Java Programming Language adds a further aspect to this discussion: when should named interfaces be introduced? Most textbooks follow the historical development of the mechanism and cover interfaces after the discussion of abstract classes. In this paper a different approach is described: interfaces are introduced long before and in isolation from inheritance; and the discussion of inheritance is explicitly split into its two major constituents, namely subtype polymorphism and implementation inheritance. We applied this novel approach in the two introductory courses on software development (SD1 and SD2) in the newly created Bachelor of Science in Informatics curriculum at the University of Hamburg, Germany. This experience report reflects on the design rationale behind this new approach.

show abstract

Section: Type Abstractionmentioning

confidence: 96%

Teaching inheritance concepts with Java

Schmolitzky

2006

Proceedings of the 4th International Symposium on Principles and Practice of Programming in Java - PPPJ '06

View full text Add to dashboard Cite

show abstract

“…Of well-known object-oriented languages, Cecil [37] supports retroactive subtyping, and the feature has been suggested for Java as well [4]. Also, mechanisms for specifying structural subtyping relations have been proposed for C++ [5] and for Java [33].…”

Section: Related Workmentioning

confidence: 99%

Concepts

Gregor

Järvi²,

Siek

et al. 2006

Proceedings of the 21st Annual ACM SIGPLAN Conference on Object-Oriented Programming Systems, Languages, and Applications

106

View full text Add to dashboard Cite

Generic programming has emerged as an important technique for the development of highly reusable and efficient software libraries. In C++, generic programming is enabled by the flexibility of templates, the C++ type parametrization mechanism. However, the power of templates comes with a price: generic (template) libraries can be more difficult to use and develop than non-template libraries and their misuse results in notoriously confusing error messages. As currently defined in C++98, templates are unconstrained, and type-checking of templates is performed late in the compilation process, i.e., after the use of a template has been combined with its definition. To improve the support for generic programming in C++, we introduce concepts to express the syntactic and semantic behavior of types and to constrain the type parameters in a C++ template. Using concepts, type-checking of template definitions is separated from their uses, thereby making templates easier to use and easier to compile. These improvements are achieved without limiting the flexibility of templates or decreasing their performance-in fact their expressive power is increased. This paper describes the language extensions supporting concepts, their use in the expression of the C++ Standard Template Library, and their implementation in the ConceptGCC compiler. Concepts are candidates for inclusion in the upcoming revision of the ISO C++ standard, C++0x.

show abstract

“…A problem with a single class hierarchy defining both abstract types and their implementations is that as the type hierarchy becomes more complex, it might become necessary to duplicate code. We use an example from computer algebra [3,2] to demonstrate this problem. Consider the abstract type GeneralHatrix with subtypes BegativeDefiniteHatrix and Orthogonal-Matrix.…”

Section: Separation Of Type and Class Hierarchiesmentioning

confidence: 99%

“…To see where this type of solution breaks down, consider adding another type, S'tack, with member functions push and pop. With signatures it is simple to define a Stack signature and whenever assigning a DoublyLinkedList use a view [2] to rename enqueueBead to push and dequeueHead to pop.…”

Section: Signatures To Implement Conflicting Type and Class Hierarchiesmentioning

confidence: 99%

See 1 more Smart Citation

Implementing signatures for C++

Baumgartner

Russo

1997

ACM Trans. Program. Lang. Syst.

Self Cite

View full text Add to dashboard Cite

We outline the design and detail the implementation of a language extension for abstracting types and for decol1pling subLyping and inheritance in C++. This extension gives the user more of the flexibility of dynamic typing while retaining tltc efficiency and security of sLaiic typing. After a brief discussion of syntax and semantics of this language extension and examples of its usc, we present and analyze the cost of three different implementation techniques: a preprocessor to a C++ compiler, an implementation in the front end of a. C++ compiler, and a low-level implementation with back end support. Finally, we discuss the lessons we learned for fut.ure programming language design. 1. Using the same construct (class inheritance) for type abstraction and code sharing limits the power of both and unnecessarily couples implementation and interface specifications.2. In some cases, it is difficult (if not impossible) to retroactively introduce abstract base classes to a class hierarchy for the purpose of type abstraction.3. The hierarchy of abstract types and the class hierarchy of implementations may be difficult to reconcile with each other.We will show how signatures allow us to overcome these problems without a major overhaul of the C++ type system. Separation of Type and Class HierarchiesA problem with a single class hierarchy defining both abstract types and their implementations is that as the type hierarchy becomes more complex, it might become necessary to duplicate code. We use an example from computer algebra [3,2] to demonstrate this problem. Consider the abstract type GeneralHatrix with subtypes BegativeDefiniteHatrix and Orthogonal-Matrix. Both subtypes have functions that are not present in general matrices, e.g., the function inverse(). Assume we have several different implementations of these abstract types, namely DenseMatrix, which implements matrices as two-dimensional arrays, SparseMatrix, which uses lists of triples, and Permutation-Matrix, which is implemented as a special case of sparse matrices that takes advantage of permutation matrices only having one element in each row and column.If we try to model these types and implementations with a single class hierarchy, we end up either duplicating code or violating the type hierarchy. While DenseMatrix can be made a subclass of the abstract classes GeneralMatrix, HegativeDefiniteMa'trix, and OrthogonalHatrix by using multiple inheritance, we cannot do the same for SparseMatrix. Doing so would make PermutationHatrix, which is a subclass of SparseHatrix, an indirect subclass of NegativeDefiniteHatrix. Since permutation matrices are positive definite, this would violate the type hierarchy. The alternative of having a separate class SparseNegativeDefiniteHatrix is not satisfying either since it causes code replications.Similar arguments have been given in the literature to show that the collection class hierarchy of SMALLTALK~80 [13] is not appropriate as a basis for subtyping. While the problem does not arise with dynamic typing, it becomes an issu...

show abstract

Signatures: A language extension for improving type abstraction and subtype polymorphism in C++

Cited by 20 publications

References 21 publications

Teaching inheritance concepts with Java

Teaching inheritance concepts with Java

Concepts

Implementing signatures for C++

Contact Info

Product

Resources

About