C++ : Pointer to "new Class()" function - c++

Question

I have a Parent abstract class, and derivated Foo and Bar classes. They all have a constructor taking a string name parameter. They have a string type() member function which returns "foo" and "bar" respectively.
Now I would like to build a dictionnary with keys "foo" and "bar", and values equal to pointers to functions creating a new instance of the corresponding class. This means these pointers will be of type Parent* (*) (const string &) and executing them will be equivalent to calling new Foo(name) and new Bar(name)
Can I avoid creating a static function for each class that will just call new, and get a pointer to this static function?
Thanks!
Edit : Actually, the goal behind this is implementing a plugin system in my app, the plugins adding new Derived class types. The plugin authors are generally my customers, and for this reason, I want to let them the most simple and elegant interface possible. So declaring and registering the factory functions should be as simple and as short as possible for them

Answer 1

Can I avoid creating a static function for each class that will just call new, and get a pointer to this static function?
Yes, you can create a generic function:
template <typename T>
ptr_type<Parent> create() {
return new T();
}
… and then take its address (but you need to get an address per derived type).
Note that I have explicitly not used T* as a return type – raw pointers should never own memory … an appropriate smart pointer should instead be used here.

Answer 2

What you describe is a factory method pattern.
Here's a link: http://en.wikipedia.org/wiki/Factory_method_pattern
The static function or a factory of some sort basically the thing you want.
Why do you want to avoid the static creation method?

Answer 3

You need to instantiate a factory function for each class you want to be able to build by this means. The following code shows you how to do so without having to recur to static members and by not writing by hand a number of different functions:
#include <iostream>
#include <map>
#include <functional>
#include <string>
#include <memory>
struct Parent{
Parent(std::string){}
};
struct Child1 : public Parent{
Child1(std::string d) : Parent(d){
std::cout << "Child1 constructor: " << d << std::endl;
}
};
struct Child2 : public Parent{
Child2(std::string d) : Parent(d){
std::cout << "Child2 constructor: " << d << std::endl;
}
};
template <typename Product, typename Return, typename Parameter>
Return factory(const Parameter& a){
return Return(new Product(a));
}
std::map<std::string, std::function<Parent*(std::string)> > mrp;
std::map<std::string, std::function<std::shared_ptr<Parent>(std::string)> > msp;
int main(){
mrp["Child1"] = &factory<Child1, Parent*, std::string>;
mrp["Child2"] = &factory<Child2, Parent*, std::string>;
Parent* a = mrp["Child1"]("one");
delete a;
std::unique_ptr<Parent> b(mrp["Child2"]("two"));
msp["Child1"] = &factory<Child1, std::shared_ptr<Parent>, std::string>;
msp["Child2"] = &factory<Child2, std::shared_ptr<Parent>, std::string>;
msp["Child1"]("one");
msp["Child2"]("two");
}
try this code here.
Also, as you can see, this method can be "configured" to use std::shared_ptr, raw pointers, ... and with different ownership semanthics, notice the line:
std::unique_ptr<Parent> b(mrp["Child2"]("two"));
However, any variation of what you briefly described in the question is, well, a variation of it! What you are trying to do is an abstract factory, which "standard" implementation relies exactly on making a factory function for each class you want to build. As I said, it doesn't need to be a static member of the class, it can well be a non-member non-friend function but this doesn't change very much (except better encapsulation, and the need for the constructor being public, or for the factory to be friend, which, somehow, breaks encapsulation).
The object factory is implemented in a very elegant way in loki. Refer to Modern C++ (Alexandrescu) for a thorough discussion of the design pattern itself as well as of the implementation given by loki.
As for your edit: registration in loki is sweet and simple as in (cited from the book):
// Implementation module for class Line
// Create an anonymous namespace
// to make the function invisible from other modules
namespace
{
Shape* CreateLine()
{
return new Line;
}
// The ID of class Line
const int LINE = 1;
// Assume TheShapeFactory is a singleton factory
// (see Chapter 6)
const bool registered =
TheShapeFactory::Instance().RegisterShape(
LINE, CreateLine);
}