调用模板化成员函数与模板化全局函数以在通用工厂中创建对象

Question

Having searched online for different approaches to the Factory pattern, I've implemented my own version which I'm quite satisfied with. The Register member function creates a function pointer for the template type, storing it in a std::map using the index as the key. This below code compiles and runs without hassle (Windows 7 64-bit, Code::Blocks 10.05 with GCC).

#ifndef OBJECT_FACTORY_HPP
#define OBJECT_FACTORY_HPP

#include <map>

namespace internal {
    template<typename BaseType, typename ObjectType>
    BaseType* CreateFunction() {
        return new ObjectType;
    }
}

template<typename BaseType, typename IndexType>
class ObjectFactory {
    public:
        ObjectFactory();

        template<typename ObjectType>
        bool Register(const IndexType& index);

        bool Unregister(const IndexType& index);

        BaseType* Create(const IndexType& index);

    private:
        typedef BaseType* (*creationCallback)();
        typedef std::map<IndexType, creationCallback> Registry;
        Registry registry;

//    private:
//        template<typename ObjectType>
//        BaseType* CreateFunction();
};

template<typename BaseType, typename IndexType>
ObjectFactory<BaseType, IndexType>::ObjectFactory() {
    registry.clear();
}

template<typename BaseType, typename IndexType>
template<typename ObjectType>
bool ObjectFactory<BaseType, IndexType>::Register(const IndexType& index) {
    if (registry.find(index) != registry.end())
        return false;

    registry[index] = &internal::CreateFunction<BaseType, ObjectType>;
    // registry[index] = &CreateFunction<ObjectType>; <-- FAILS!
    return true;
}

template<typename BaseType, typename IndexType>
bool ObjectFactory<BaseType, IndexType>::Unregister(const IndexType& type) {
    if (registry.find(type) == registry.end())
        return false;

    return (registry.erase(type) == 1);
}

template<typename BaseType, typename IndexType>
BaseType* ObjectFactory<BaseType, IndexType>::Create(const IndexType& index) {
    if (registry.find(index) == registry.end())
        return NULL;

    return registry[index]();
}

//template<typename BaseType, typename IndexType>
//template<typename ObjectType>
//BaseType* ObjectFactory<BaseType, IndexType>::CreateFunction() {
//    return new ObjectType();
//}

#endif

My original approach was to have CreateFunction as a private member to hide it from users (look at the commented sections, note the non-member function takes an additional template argument). However, this fails with the following error messages, all pointing to the line where I store the function pointer in the Register member function:

In member function 'bool ObjectFactory<BaseType, IndexType>::Register(const IndexType&) [with ObjectType = Triangle, BaseType = Shape, IndexType = std::basic_string<char, std::char_traits<char>, std::allocator<char> >]':|
instantiated from here
error: no matches converting function 'CreateFunction' to type 'class Shape* (*)()'|
error: candidates are: template<class ObjectType> BaseType* ObjectFactory::CreateFunction() [with ObjectType = ObjectType, BaseType = Shape, IndexType = std::basic_string<char, std::char_traits<char>, std::allocator<char> >]|

I wrote a small test client for testing:

#include "ObjectFactory.hpp"
#include <iostream>

class Shape {
    public:
        Shape() {}
        virtual void print() { std::cout << "At heart, I'm a shape"; }
};

class Triangle : public Shape {
    public:
        Triangle() {}
        void print() { Shape::print(); std::cout << ", but I'm truly a triangle" << std::endl; }
};

int main(int argc, char* argv[]) {
    ObjectFactory<Shape, std::string> objectFactory;

    objectFactory.Register<Triangle>("triangle");

    Shape* triangle = objectFactory.Create("triangle");
    triangle->print();

    delete triangle;

    return 0;
}

Is this even possible? I feel it should be, and I understand that I'm somehow calling the incorrect member function, but I'm can't see why. On a related note, since someone might mention it, I plan on using *boost::shared_ptr* for the allocation instead of the plain new operator ;) Any other advice or suggestions about the implementation are also welcome.

Answer 1

From within our file, we anonymize our namespace:

// namespace internal {  
   namespace          {
    template<typename BaseType, typename ObjectType> 
    BaseType* CreateFunction() { ... }  
}

The non-static function can now be called as originally written, without the namespace qualification:

// registry[index] = &internal::CreateFunction<ObjectType>;  
   registry[index] =           &CreateFunction<ObjectType>; 

The file-scoped CreateFunction function is invisible to code outside of the translation unit and is called only by the class ObjectFactory .

This approximates well the private access specifier for the CreateFunction (from within the ObjectFactory ) proposed in the question.

Answer 2

The creating function should be a static member:

template<typename ObjectType> static BaseType* CreateFunction();

(the above code, without the static , is commented-out in your example).

Now your other commented-out code is valid:

registry[index] = &CreateFunction<ObjectType>;

---

Edit: to clear up some confusion:

The problem here is mostly in syntax. Templates and private are not important here, so let's simplify the situation:

struct ObjectFactory {
    void CreateFunction() {std::cout << "message";}
    void AnotherFunction()
    {
        ... = &CreateFunction; // what's that?
    }
};

If CreateFunction is a nonstatic member function, the syntax &CreateFunction is incorrect; i guess that gcc complains just about that. To make things worse, however, MS Visual Studio tries to "help" you by internally "correcting" the syntax to &ObjectFactory::CreateFunction and trying to use that; but it fails with unintelligible error messages (the fact that you have templates aggravates them even more).

I am not sure about the Visual Studio part (i remember having such trouble with MSVC 6 a few years ago; a newer version of Visual Studio doesn't have this problem).