Re: enforcing the constructor interface?
patrik.kahari@sofe.nu wrote:
Antti Virtanen wrote:
MyBase* ptr = new FancyClass(a,b);
MyBase* ptr = new MegaClass(a,b); // this is so elegant
MyBase* ptr = new GigaClass(a,b,c,d); // and this is bad, but why?
My thought is it would be useful because clients could write pluginable
classes, and I could create a engine that can create instances of these
classes without having to know their specifics. This is what I meant by
a plugin.
Your engine may not have access to definitions of plugin classes and
it's usually the case.
One could do this with pointers to theirs constructors or as
you mention with templates. The constructor pointer (or the template
type) has to be specified at some point. This can be done at runtime by
parsing a script file.
There are no pointers to constructors in C++.
[]
Am I making any more sense now, or am I still missing your point?
The common solution is the following. Plugin classes conform (derive)
to an interface defined in your plugin framework. Plugin shared objects
(.so/.dll) export a factory function with a name and a signature
expected by the framework. The main application loads .so objects,
finds factory functions by name and invoke them to create plugin
objects. Factory functions have to accept the same set of arguments as
hardcoded in the framework. Plugin object constructors can accept as
many arguments as they wish. It's the job of factory functions to know
the exact type of the plugin class and provide necessary arguments to
its constructor.
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]