Re: extending c++ classes and enumerations

James Kanze skrev:


The drawbacks is that you miss all lexical benefits C++will give you.
:-) Both old Pascal and modern JavaScript supports encapsulation with
the WITH-statement.

Secondly, XML parser Expat can be a sample how difficult it is to read
such source. The first time I saw Expat source-code I thought it was
written in C++ and then preprocessed into C with some utility parser.

Thirdly, projects that uses "light C++" (not using RTTI, templates and
exceptions in the code) only use C++ for these "lexical benefits", and
I can give examples of such project.

Adding support for extending classes is hopefully a toll-free change if
it is limited to static and non-virtual functions. This means that you
wouldn't need to recompile and relink existing C++ libraries. But of
course, this is in theory.

There would be even more benefits if one could extend with virtual
functions, too. I suppose adding static and non-virtual methods is
taken care at compile-time, wheras adding virtual functions to the
vtable must be done at runtime.

Sorry if I'm posting a giant message, but I want to touch one thing
more. :-)

Extending classes feels like the next step in creating reusable code,
one of the primary goal of C++, according to Stephen Pratas book. Let
me give another example, if adding virtual functions would be allowed.

If we, for example, want to add Model View Controller functionality to
a GUI library, say wxWindow similar library where all classes derive
from Object , then we can write code the traditional way and
conditionalize it within #ifdefs and release a new major library
version. Or we could make life eaiser with class extending and release
a minor version and an extra library for our MVC code.

Since the changes to the existing GUI library will be limited to Object
and EventHandler, our extra code resides in an own library. The class
Object will only be patched with extending. Class EventHandler, the
base class for all GUI elements like buttons and controls, needs to
modified little, the rest is handled by extending.

// Object+KeyValueCompilance.h
extend class Object {
 virtual void setValueForKey(const char *key, Object *value) = 0;
 virtual Object *valueForKey(const char *key) = 0;
 virtual void bindTo(Object *anObject) = 0;
 virtual void unbind(Object *anObject) = 0;
};

// EventHandler.h
class EventHandler : public Object {
#ifdef KEYVALUECOMPILANCE
 Array *arrayOfBoundedObjects;
#endif
 // ...
};

// EventHandler+KeyValueCompilance.h
extend class EventHandler : public Object {
 virtual void bindTo(Object *anObject);
 virtual void unbind(Object *anObject);
};

Of course, the MVC extension to the GUI library has its own classes,
that is perhaps larger than the GUI library itself.

Note that I'm not familiar with the wx library, but it is a well known
C++ library.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]