sdm@cs.brown.edu (Scott Meyers) (11/02/90)
Summary: We need a way to specify that a virtual function's implementation should not be inherited. There are currently three general ways of declaring member functions, with three corresponding meanings. For a class C, we can say: 1. void C::foo() { ... } 2. virtual void C::foo() { ... } // yes, I know "virtual" is 3. virtual void C::foo() = 0; // illegal outside the class decl... In all three cases, foo is a concept that makes sense for all objects of type C or any of its subclasses, but there are additional semantics, as follows: 1. foo's implementation makes sense for all objects of type C or any of its subclasses. In essense, foo's implementation is an assertion about an *invariant* aspect of C's semantics, and redefinitions of foo in subclasses are suspect. 2. foo's implementation provides reasonable default semantics for C objects and specializations of C, but foo's implementation often needs to change as C is specialized. 3. it is not possible to provide default behavior for foo, but the concept applies to all objects of type C, and a definition for foo must be provided before a subclass may be instantiated. I propose that we need a forth form, one that means: 4. foo identifies an attribute which MUST differentiate specializations of C, hence no definition of foo may be inherited. (This is in some sense the diametric opposite of case 1.) As a contrivied example, consider a function we're never supposed to need, but that is damned useful nonetheless: virtual const char * C::className() const { return "C"; } Here is a member function that should *always* be redefined in subclasses. Unfortunately, there is no way to require that it be done. To get the semantics I propose, we need new syntax, always a bad sign. For pure virtual functions, a simple application of the "when in doubt, assign a new meaning to 'const'" rule seems possible: virtual void C::foo() const = const 0; ^^^^^ // foo is pure virtual in C, and once defined, it must be // defined in all further subclasses. (The extra const suggests // "it's inherited definition is ALWAYS null.") For non-pure (impure?) virtual functions, I'm not sure what to suggest; the last thing we need is another keyword. Has anybody besides me ever wanted to have a way to express a requirement that a function MUST be redefined in subclasses? Scott sdm@cs.brown.edu