C ++ статический шаблон с внешней реализацией

Question

У меня есть простой шаблон реестра:

class Object
{
//some secondary simple methods
};

#define OBJECT_DEF(Name) \
 public: \
  static const char* Name() { return Name; } \
 private:


class Registry
{
 struct string_less {
  bool operator() (const std::string& str1, const std::string& str2) {
   for(int i = 0; i < str1.size() && i < str2.size(); ++i) {
    if(str1[i] != str2[i])
     return str1[i] < str2[i];
   }
   return str1.size() < str2.size();
  }
 };

 typedef boost::shared_ptr < Object> ptrInterface;
 typedef std::map < std::string,  ptrInterface, string_less > container;
 container registry;

 static Registry _instance;

 ptrInterface find(std::string name);

protected:
 Registry () {}
 ~Registry () {}


public:


 template < class T >
 static T* Get(); // I want to write so !!!

 template < class T >
 static bool Set(T* instance, bool reSet = false);
};

И если у меня есть класс, который exteds Object:

class Foo : public Object {
    OBJECT_DEF("foo");
//smth
};

Я хочу использовать Реестр таким образом:

Registry::Set(new Foo());

или

Registry::Get<Foo>();

Как я могу эмулировать статические шаблоны с внешней реализацией?

Answer 1

Я бы не использовал хак с OBJECT_DEF ()

У каждого класса есть уникальное имя (определенное компилятором), к которому можно получить доступ через type_info

Я бы тогда использовал повышениеобъект для хранения этой информации на карте.

Я не проверял это.
Но регистрация теперь должна работать с любым типом.

#include <map>
#include <boost/any.hpp>
#include <typeinfo>
#include <string>
#include <iostream>

class Register
{
    static std::map<std::string, boost::any>       data;

    public:
        // If you just want to store pointers then:
        //     alter the input parameter to Set() to be T*
        //     alter the output of Get() to be T* and modify the any_cast.
        // 
        // If you are just storing pointers I would also modify the map
        // to be a boost::pointer_map so that ownership is transfered
        // and memory is cleaned up.
        template<typename T>
        static void Set(T const& value)
        {
            data[std::string(typeid(T).name())] = boost::any(value);
        }

        template<typename T>
        static T Get()
        {
            return boost::any_cast<T>(data[std::string(typeid(T).name())]);
        }


};

std::map<std::string, boost::any>       Register::data;

int main()
{
    // Currently this line will leak as register does not take ownership.
    Register::Set(new int(1));

    // This line works fine.
    Register::Set(int(5));

    std::cout << *(Register::Get<int*>()) << "\n";
    std::cout << Register::Get<int>() << "\n";
}