只能生成一个对象的类（经典设计模式之一）

#include   <iostream>   
    
  //   singleton   
  class   A   
  {   
                  public:   
                                  static   A*   GetInstance(void)   
                                  {   
                                                  if   (   m_pInstance   ==   NULL   )   
                                                                  m_pInstance   =   new   A();   
                                                  return   m_pInstance;   
                                  }   
                                  //   test   function   
                                  void   display()   
                                  {   
                                                  std::cout   <<   "Hello,   world"   <<   std::endl;   
                                  }   
    
                  private:   
                                  //   default   constructor   
                                  A()   {   
                                                  std::cout   <<   "construction\n";   
                                  }   
    
                  private:   
                                  static   A*   m_pInstance;   
  };   
    
  //   init   static   m_pInstance   
  A*   A::m_pInstance   =   NULL;   
    
  int   main()   
  {   
                  A*   ptr1   =   A::GetInstance();   
                  A*   ptr2   =   A::GetInstance();   
    
                  ptr1->display();   
                  ptr2->display();   
    
                  //A*   ptr3   =   new   A;                     //   forbidden   
                  //A     obj;                                       //   forbidden   
    
                  return   0;   
  }   
  //   


//示例而已

【xxyyboy】:
定义为 static ini 类的函数
用1static 类指针来直接返回已经初始化过的实体

楼上的都是正确的例子。

【Cocoky】:
singleton

【zwlzwlzwl】:
Class Singleton{
static Singleton s;
int i;
Singleton(int x):i(x) { }
Singleton& operator=(Singleton&);
Singleton(const Singleton&);
public:
  static Singleton& instance() { return s;}
  int getvalue() { return i;}
  void setvalue() { i = x;}
//关键是在类中声明一个类的实例，并将构造函数、拷贝构造函数、赋值构造函数声明为私有的，这样就能防止调用默认构造函数声明类的实例，只能用类的函数instance为一个新地向赋值，这样就保证了一个对象只实例一次。
int main（）
{
   Singleton& s = Singleton::instance();
   cout<<s.getvalue()<<endl;
   Singleton& s2 = Singleton::instance();
   cout<<s2.getvalue()<<endl;
}
}