请问如何实现一个类只被实例化一次？

单例类，手机无力给不了代码，不过论坛一大堆，看看吧。

用单例模式啊

1. public class Singleton {
   
2.      //私有的默认构造子
   
3.      private Singleton() {}
   
4.      //注意，这里没有final   
   
5.      private static Singleton single=null;
   
6.      //静态工厂方法
   
7.      public synchronized  static Singleton getInstance() {
   
8.           if (single == null) {  
   
9.               single = new Singleton();
   
10.           }  
    
11.          return single;
    
12.      }
    
13. }

复制代码

#include <iostream>

class Singleton
{
public:
   Singleton(){}

   static Singleton* GetSingleton();
private:
   Singleton(){};
   
   static Singleton* pTHIS;
};

Singleton* Singleton::pTHIS = NULL;

Singleton* Singleton::GetSingleton()
{
   if (!pTHIS) pTHIS = new Singleton();

   return pTHIS;
}

int main()
{
   using namespace std;

   Singleton* pOne = Singleton::GetSingleton();
   Singleton* pTwo = Singleton::GetSingleton();

   cout<<"Address of pOne: "<<pOne<<endl;
   cout<<"Address of pTwo: "<<pTwo<<endl;
  
   system("pause");
return 0;
}
如果在函数调用类时也不希望出现类的复制,那么拷贝构造函数也需要声明为私有方法

我就单例的思想吧，：1不让其他程序建立此类对象，2，在此类内部自己建立一个，3对外提供一些访问方式
在java中的体现：1，将构造函数私有化。2，在本类中创建一个本类对象，3提供一个可以获取到该对象的方法。

我就单例的思想吧，：1不让其他程序建立此类对象，2，在此类内部自己建立一个，3对外提供一些访问方式
在java中的体现：1，将构造函数私有化。2，在本类中创建一个本类对象，3提供一个可以获取到该对象的方法。

及时追问，或将帖子分类改成【已解决】~

单例设计模式：解决一个类在内存中只存在一个对象（保证一个类在内存中的对象唯一性）。
(1)单例设计模式：饿汉式
Single类一进内存，就已经创建好了对象。
class Single{
        private Single(){}
        private static Single s=new Single();//创建一个私有并静态的对象（当方法是静态时···）私有静态成员对象，是为了可控（传递参数加以限制）。
        public static Single getInstance(){//构造函数私有化，不能通过创建对象调用该方法，只能通过类名调用，这时，就要使用static
                return s;
        }
}

(2)懒汉式(对象是方法被调用时，才初始化，也叫做对象的延时加载)
Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
class Single{
        private Single(){}
        private static Single s=null;
        public static Single getInstance(){
                if(s==null){
                        synchronized(Single.class){
                                if(s==null){
                                        s=new Single();
                                }
                        }
                }
                return s;
        }
}
使用双重if条件判断语句的原因：当线程—0进来时，使用锁进入第二个if条件判断语句之后，就在那挂着，那么线程—1进来，判断null，判断锁，有线程使用，则进不了，此时，线程—0获取了执行权，返回s，结束线程。线程—1进来拿到锁了，判断第二个if条件不为空，则无法创建对象。此时，再来一个线程—2，判断第一个条件已经不在为空了，此时，直接就进不了，以后的线程都进不来了。这样就提高了效率，而加同步代码块，则提高了安全性。
注意锁的使用问题，这里的锁不能是this和getClass，他们都是非静态的。

曾祥旭 发表于 2013-3-27 21:03
单例设计模式：解决一个类在内存中只存在一个对象（保证一个类在内存中的对象唯一性）。
(1)单例设计模式： ...

很详细、还分别给出了饿汉式和懒汉式