Lib中的static变量怎么会对外不可见

星の海

#define DECLARE_SINGLETON(T) \
        private:\
                static Singleton<T> m_Singleton;\
        public:\
                static T& Instance(void)\
                {\
                        return m_Singleton.Instance();\
                }\
                static T* InstancePtr(void)\
                {\
                        return m_Singleton.InstancePtr();\
                }\
                static void Destroy(void)\
                {\
                        m_Singleton.Destroy();\
                }
        template<class T>
        class EXPORT Singleton
        {
        public:
                T* m_Instance;
                Singleton(void)
                {
                        m_Instance = 0;
                }
                T& Instance(void)
                {
                        return *InstancePtr();
                }
                T* InstancePtr(void)
                {
                        if(!m_Instance)
                                m_Instance =  new T;
                        return m_Instance;
                }
                void Destroy(void)
                {
                        delete m_Instance;
                }
        };
class EXPORT A
{
     DECLARE_SINGLEOTON
}

星の海

现在想想好像那个模板好像是唬唬人的，去掉也不已紧

tarkey

：） 你为什么要包两层呢？

而且你这样的实现不叫singleton，singleton的标准实现是：
class A;
static A *A::m_Instance = 0;
static A *A::GetInstance() { return (m_Instance?m_Instancem_Instance=new A())); }
#define SINGLETON_A (A::GetInstance())

这才是标准的singleton，singleton的关键在于，你可以有方法获得
某个类在内存中的唯一地址。比如有了上面的声明，我们可以在程序
的任何一个地方直接用SINGLETON_A来操纵A。并且，对于SINGLETON
我们可以简单的认为SINGLETON类在内存中只有一个拷贝。

SevenCat

singleton可以这样做
template <typename T>
class Singleton
{
Singleton(){}
~Singleton(){}
public:
static T &getInstance()
{
  static T obj;
  return obj;
}
}

星の海

class A是只有一个实例，我只是加了一个模板类，为什么这么做我也不记得了。反正实现方法不同而异，原理是一样的。
我不是因为Singleton不对才有问题的，我的problem是static变量对外不可见，我拿出Singleton是因为大部分的static都是Singleton成员,但是还有一些其他类的static同样不可见，所以问题出在static变量上，所以我才要发扬问问题的优良传统！欢迎继续讨论讨论，谢谢各位

星の海

不过类上那位的Singleton方法不错，我没想到。

SevenCat

干脆来贴全了，新的singleton基本上都是这么实现的。
template<class T>
class singleton: private T
{
private:
    singleton();
    ~singleton();

public:
    static T &instance();
};


template<class T>
inline singleton<T>::singleton()
{   /* no-op */ }

template<class T>
inline singleton<T>::~singleton()
{   /* no-op */ }


template<class T>
/*static*/ T &singleton<T>::instance()
{
    // function-local static to force this to work correctly at static
    // initialization time.
    static singleton<T> s_oT;
    return(s_oT);
}


// T must be: no-throw default constructible and no-throw destructible
template <typename T>
struct singleton_default
{
  private:
    struct object_creator
    {
      // This constructor does nothing more than ensure that instance()
      //  is called before main() begins, thus creating the static
      //  T object before multithreading race issues can come up.
      object_creator() { singleton_default<T>::instance(); }
      inline void do_nothing() const { }
    };
    static object_creator create_object;

    singleton_default();

  public:
    typedef T object_type;

    // If, at any point (in user code), singleton_default<T>::instance()
    //  is called, then the following function is instantiated.
    static object_type & instance()
    {
      // This is the object that we return a reference to.
      // It is guaranteed to be created before main() begins because of
      //  the next line.
      static object_type obj;

      // The following line does nothing else than force the instantiation
      //  of singleton_default<T>::create_object, whose constructor is
      //  called before main() begins.
      create_object.do_nothing();

      return obj;
    }
};
template <typename T>
typename singleton_default<T>:bject_creator
singleton_default<T>::create_object;

tarkey

singleton的实现方法很多，楼上这样做的代价就是多申请了一些内存：）

回 星の海：

感觉你的实现方法真的很别扭，完全没有包个中间层。
直接要么用宏，要么用个singleton class就能实现了。
并且一般的做法都是对m_Instance这个变量做static

SevenCat

rt

tarkey

。。。你贴了两种实现方法是吧。。
第一种用继承的方法没多内存。。。
第二种多了个
static object_creator create_object;

不过第一种方法为什么要private继承呢？
如果直接用class singleton: public T继承的话，就可以直接用
singleton<XXX>::instance()来获得singleton实体。