小编ohn*_*nyj的帖子

我正在编写一个实用程序类库,其中许多是单例.我使用继承实现了它们:

template <class T>
class Singleton {
    public:
        T& getInstance() {
            if(m_instance == 0) {
                 m_instance = new T;
            }

            return m_instance;
        }
    private:
        static T* m_instance;
};

class SomeClass : public Singleton<SomeClass> {
    public:
        SomeClass() {}
        virtual ~SomeClass() {}

        void doSomething() {;}
};

显然这是一个简单的例子,而不是一个真正的类.无论如何,我发现使用如下代码:

SomeClass::getInstance().doSomething();

将创建SomeClass的多个实例.我想这可能是因为它在我的库(.a)文件之外以及内部使用.例如,我使用的是一个非自己编写的UI库,它是单独编译的,我正在添加它.其中一些添加使用单体,这些单体也在我的.a库中使用.

单独的编译会导致这种情况吗？别的什么？

我设法解决这个问题的唯一方法是在main.cpp文件中创建一个全局对象,我用我需要的任何单例初始化它.然后,所有代码都通过以下调用访问此公共全局对象:

GlobalObject::getSomeClass().doSomething()

我不想每次创建另一个单例时都要为这个对象添加一个额外的方法.使用第一种访问方法,语法似乎更清晰,更熟悉:

SomeClass::getInstance().doSomething();

如果您有任何想法,意见等,请告诉我.

谢谢.

首先是免责声明,我正在替换一堆使用boost :: function和boost :: bind的代码.但是,我正在转向不允许rtti的代码库.我想继续使用提升,但不知道是否有办法解决这个限制.

所以,我试图模仿它的一些功能,但更简化.我有一个Callback类:

   template <class Class, typename ReturnType = void> class Callback0 {
   typedef ReturnType (Class::*Method)();

   public:
       Callback0(Class* object, Method method)
           : m_object(object)
           , m_method(method)
       {
          ;
       }

       Callback0(const Callback0& callback)
           : m_object(callback.m_object)
           , m_method(callback.m_method)
       {
          ;
       }

       operator bool() {
           return m_object != 0;
       }

       operator bool() const {
           return m_object != 0;
       }

       ReturnType operator()() {
           return (m_object->*m_method)();
       }

       Callback0<Class, ReturnType>& operator=(const Callback0<Class, ReturnType>& callback) {
           if(this != &callback) {
               m_object = callback.m_object;
               m_method = …