Re: static virtual functions
james.kanze@gmail.com (James Kanze) wrote (abridged):
I know that the model for Smalltalk is different. But Smalltalk
is not statically type-checked, so a lot of things are
different: what makes sense in Smalltalk may not make sense in
C++, and vice versa.
The code I showed was statically type-correct.
But I agree, once you have meta-classes you want to use them for more
things and the whole language would want to change. For example, instead
of having constructors as special member functions, in Smalltalk they are
normal member functions of the meta-class.
---somewhere, something's got to break the infinit recursion, and
I suspect that A::__Class isn't a class like the others, because
IT doesn't have a meta-class.
It is system-generated and so can't itself have static virtual member
functions. So the meta-meta-class can be the same type for all classes. In
particular, it can be its own meta-class. What we have is not an infinite
recursion, but a loop.
(As I recall you get the same loop in Java. If you ask Integer for its
class the answer is an instance of Class. And if you ask /that/ for its
class the answer is another instance of Class.)
And if I write MyClass::staticFunc(), virtuality certainly can't play
a role, since there's no way the compiler can possibly resolve it.
I've explained how the compiler can supply the object for that case.
(MyClass could easily have twenty different derived classes,
each with a different overriding function.)
That's irrelevant, because the code specifies MyClass, not one of its
subclasses.
What I'm looking for is a scenario which shows how this mechanism
gets actually used.
One use is for factory functions.
class Base {
virtual static Base *inner_make() = 0;
virtual void init() {};
public:
static Base *make() {
Base *p = inner_make();
p->init();
return p;
}
};
class Derived : public Base {
virtual static Base *inner_make() { return new Derived; }
public:
};
Base *p = Derived::make();
Here Base::make() is static so we can use it to make the first object.
Derived inherits it as usual. Base::make() calls the virtual static
function inner_make() and Derived can override it to create the instance
of the appropriate type. Then Base::make() invokes init() on the new
instance as a normal virtual function. Because this happens outside of the
object's constructor, the object has its full dynamic type.
This can also be used as:
Base::__Class *pClass = &Derived::__class;
//
Base *p = pClass->make();
where the final line doesn't need to know the static type of the object it
is creating.
And would the scenario fit into the C++ (or even the Java) model
of mainly static typechecking?
Yes.
What I haven't seen is what you can do with it that you could not do
with an extended type_info, or something like java.lang.Class.
The type of java.lang.Class is fixed by the system, so we can't add new
functions to it, especially not new virtual functions. We are stuck with
whatever facilities it provides. We can't add new ones or override the
implementation of the standard ones without, in effect, adding our own
meta-class system.
-- Dave Harris, Nottingham, UK.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]