一个类只实例化出一个对象称为单例模式
 

 
#include <iostream>

class SingleClass
{
public:
    static SingleClass* GetSingleClass()    //静态成员函数
    {
        if (Count > 0)
        //如果Count大于0，那么就调用new创建一个类指针，并且计数Count减1，否则返回NULL
        {
            Count--;
            return new SingleClass();
        }
        else
        {
            return NULL;
        }
    }
private:
    SingleClass(){};
    static int Count;   //静态成员变量Count，不允许在类中初始化。定义为const则可以在这初始化，但是不可更改，不适合在这使用
};

int SingleClass::Count = 1; //Count的初始化，可以自己设置限制创建实例的个数

int main()
{
    SingleClass* test;  //只能通过定义类指针来创建类实例
    test = SingleClass::GetSingleClass();
    return 0;
}
 
 
 

 
#include <iostream>

class SingleClass
{
public:
    static SingleClass* GetSingleClass()    //静态成员函数
    {
        if (pSinClass == NULL)
        //如果pSinClass为NULL，那么就调用new创建一个类指针，否则返回NULL
        {
            pSinClass = new SingleClass();
            return pSinClass;
        }
        else
        {
            return NULL;
        }
    }
private:
    SingleClass(){};
    static SingleClass* pSinClass;   //静态成员变量pSinClass，不允许在类中初始化。定义为const则可以在这初始化，但是不可更改，不适合在这使用
};

SingleClass* SingleClass::pSinClass = NULL; //pSinClass的初始化

int main()
{
    SingleClass* test;  //只能通过定义类指针来创建类实例
    test = SingleClass::GetSingleClass();
    return 0;
}
 
 
 
 
 
 

# include <iostream>
# include <string>
using namespace std;
 
1.创建类
 
class Student
{
public:
    static Student* Limit();  //静态成员函数
    void display();
private:
    static Student *total;    //静态数据成员指针
    Student(string ,int);
    string name;
    int age;
};
 
2.类外实现
 
//初始化静态成员数据
Student* Student::total = NULL;
Student::Student(string nam = "0",int ag = 0)
{
    name = nam;
    age = ag;
}
Student* Student::Limit()           //功能：只能通过此函数调用构造函数进行初始化，然后返回唯一对象地址
{

                    //定义bool类型的b为了实现 total = new student();只运行一次， 
                    //大概过程：（要记住 "b是静态成员" ）
                    // 1）主函数创建第一个对象
                    //   b = false（满足条件进入IF）-> b = true 执行创建对象语句->
                    //   return对象地址total
                    // 2）主函数创建第二个对象
                    //   b = true (不满足IF条件，不进入IF)不会创建新的对象，->return
                    //   对象地址total（total不变同变量b一个性质）
                    // 所以无论主函数怎样创建对象都是将第一次创建的对象的地址返回给主函数

   static bool b = false;   
    if (b == false)   
    {                               
        b = true;   
        total = new Student();   
    }   
    return total;
}

void Student::display()
{
    cout<<"名字："<<name<<"\n年龄："<<age<<endl;
}
 
3.程序入口
 
int main()
{
    //Student m("ss",12);          //不可访问，构造函数为私有成员函数
    //m.display();
    Student* a = Student::Limit(); //只能通过调用公有的静态成员函数来创建对象，返回对象的存储地址
    a->display();
    Student* b = Student::Limit(); //不是创建新的对象而是将指针b指向原有对象（a指向的对象）
    b->display();
}
 
4.讲解 
 根据上面这段代码，要想在程序中只许创建一个Student类对象，调用静态成员函数Limit()即可。 
 例如： 
 
Student MyObj(“ss”,12); // 编译出错 - 因为构造函数是 private 
 
// 获得指向类对象指针的正确方法 
 Student* pMyObj1 = Student::Limit(); 
 
// 下面的语句不会创建新的类对象，它所创建的对象指针pMyObj2与上面创建的pMyObj1指针是一样的， 
 // 也就是说pMyObj1和pMyObj2所指的对象是一样的 
 
Student* pMyObj2 = Student::Limit();
 
/****************************************分割线（2015.10.19）*************************************/
 
5.简化版(增强版) 
 1.将类类型的指针是否为空作为判断条件 
 2.解决销毁对象之后不能创建对象问题，设置析构函数将 total初始化为NULL;上面的那个程序对应将bool类型的值 true转为false ，false转为true 
 3.解决拷贝构造函数创建对象的问题 
 若主函数通过以下方式来实例化对象，会报错，拷贝构造函数为私有，不能访问
 
    Student c(*a);              /通过拷贝构造函数创建对象。这样会报错
    c.display();
 
class Student
{
public:
    static Student* Limit(); 
    ~Student();             //   增加之处 
    void display();
private:
    static Student *total;  
    Student(string ,int);
    Student(const Student &a());  // 3.增加之处
    string name;
    int age;
};
Student* Student::total = NULL;
//   1.增加之处
Student::~Student()
{
    total = NULL;
}
Student::Student(string nam = "0",int ag = 0)
{
    name = nam;
    age = ag;
}
Student* Student::Limit()   
    //    2.更改之处，改为用指针是否为空作为判断条件比上一个更好理解
    if (NULL == total)   
    {                               
        total = new Student();   
    }   
    return total;
}

void Student::display()
{
    cout<<"名字："<<name<<"\n年龄："<<age<<endl;
}
 
PS：可以通过this指针来检验是否只能实例化一个对象
 
void Student::display()
{
    cout<<"名字："<<name<<"\n年龄："<<age<<endl;
    cout<<this<<endl;   //打印this指针
}
 
结果：
 
        名字：0
        年龄：0
        00419488
        名字：0
        年龄：0
        00419488
 
主函数创建的“两个对象”存储地址是完全一致的，所以实质只实例化了一个对象

问题的起因
 
今天学习接口，继承和多态这一部分，遇到一个练习题挺好玩的。题目要求，创建一个抽象类，然后去实例化一个抽象类的对象。
 
不对啊，根据我的知识一个抽象类不能直接实例化一个对象出来，面向对象期末考试的卷子还有专门一道让你改错的题，一般抽象类直接实例化对象都是每年必考的错误点。那这个对象从哪实例化，国家分配的吗？先不管，结果随手一new就见error
 
分析
 
单身狗开始做梦，假如我已经有了对象，那到时候是不是可以跟着对象一起去见从未谋面的家长了呢？想到这流下了没有实力的泪水，等等，对啊，假如我有了一个已经实例化的对象，而这个对象又是继承自一个抽象类，实例化对象之前肯定会先实例化父类的，那不就可以实例化抽象类了。想到这马上放弃撩妹，开始撸代码
 
代码
 
只要想法想到了，代码其实很简单
 
//创建一个抽象类，实例化一个抽象类的对象
abstract class B  //创建抽象类B
{
	private String str;//私有成员变量str
	
	public B(String a)//抽象类的构造函数
	{
		System.out.println("父类的实例化");
		this.str=a;
		System.out.println(str);
	}
	
	public abstract void play();//抽象类中的play()抽象方法

}


public class A extends B  //A类继承抽象类B
{
	public A(String a)//A的构造函数
	{
		super(a);
		System.out.println("子类的实例化");
	}
	
	@Override  //覆盖父类B中的play()
	public void play()
	{
		System.out.println("重写抽象类中的play()方法");
	}
	
	public static void main(String[] args)
	{
		B b=new A("小杰杰要加油啦"); //实例化抽象类对象
	}
}
 
结果
 

 单身狗也只能自己创建对象给自己加油了，继续去构造对象啦

其实这是一道面试题。 
 这道题的思路是，我只让这个类通过一个公有函数实例化对象，即可以将构造函数设置为私有成员函数。
 
include <iostream>
using namespace std;

class Single
{
public:

    static Single& SingleCreate()
    {
        if (m == NULL)
        {
            m = new Single();
        }
            return *m;
    }
    ~Single()
    {
        delete m;
    }

    Single(const Single &a)
    {
    if (m == NULL)
    {
    m = new Single();
    }
    }

private:
    Single()
    {}
    static  Single *m;
};

Single* Single::m = NULL;

int main()
{
    Single a = Single::SingleCreate();
}
 
这是我第一次写出的代码，我本来认为这样就可以了，结果经过我的调试，发现这样写是有问题的。 
 
 
通过上面的图片可以看出，我们实例化的a的地址，跟在SingleCreate函数中返回的m的值是不同的，即这个类实例化了两个对象，这样就偏题了。 
 经过分析，我们现在来看SingleCreate函数
 
    static Single& SingleCreate()
    {
        if (m == NULL)
        {
            m = new Single();
        }
            return *m;
    }
 
这里retuen 的*m，会自动生成拷贝构造函数，因为return *m是返回一个对象，这里是返回临时变量，自动调用拷贝构造函数，因为我们没有定义拷贝构造函数，所以这里会自动生成一个拷贝构造函数。 
 所以达不到只实例化一个对象的目的 
 二经过上面的分析，经代码优化为
 

class Single
{
public:


    static Single* SingleCreatePtr()
    {
        if (m == NULL)
        {
            m = new Single();
        }
        return m;
    }
    ~Single()
    {
        delete m;
    }


private:
    Single()
    {}

    static  Single *m;
};
Single* Single::m = NULL;
int main()
{
    Single *a = Single::SingleCreatePtr();
}
 
这个时候经过调试，得到下面 
  
 这个时候就得到的是一个对象。因为传指针的实质是在传地址，不会产生临时变量。 
 现在已经解决了在返回值时只实例化一个对象的问题 
 接下来看第三个问题 
 三、构造函数 
 接下来我们在main函数中加这么一句话：
 
Single *b = a;
 
这个时候会发生什么呢？ 
 对，会实例化出另一个对象，这是因为编译器自动生成了赋值构造函数，就像上面的拷贝构造函数一样，都是编译器自动生成并调用的，那么如何防止这些情况的发生？ 
 我的方法是在类中只声明不定义拷贝构造函数以及赋值构造函数。 
 即
 
class Single
{
public:

    static Single& SingleCreate()
    {
        if (m == NULL)
        {
            m = new Single();
        }
            return *m;
    }
    static Single* SingleCreatePtr()
    {
        if (m == NULL)
        {
            m = new Single();
        }
        return m;
    }
    ~Single()
    {
        delete m;
    }


private:
    Single()
    {}
    Single(const Single &a);
    Single& operator = (const Single &a);
    static  Single *m;
};
 
即将拷贝构造函数和赋值运算符重载函数都变成私有的成员函数，在外不可调用，就避免了因为构造函数多实例化对象的情况。 
 四、通过静态局部变量
 
class Single  
{  
private:  
    Single()   //构造函数是私有的  
    {  
    }  
public:  
    static Single & GetInstance()  
    {  
        static Single instance;   //局部静态变量  
        return instance;  
    }  
};  
 
静态局部变量在GetInstance函数中被定义，初始化为0，且静态局部变量存放在内存的全局数据区。函数结束时，静态局部变量不会消失，每次该函数调用 时，也不会为其重新分配空间。它始终驻留在全局数据区，直到程序运行结束。静态局部变量的初始化与全局变量类似．如果不为其显式初始化，则C++自动为其 初始化为0。 
 静态局部变量与全局变量共享全局数据区，但静态局部变量只在定义它的函数中可见。 
 通过声明静态局部变量，但不进行初始化及赋值，那么编译器自动初始化为0，且永远不会改变，所以只会实例化一个对象。这个方法更加便捷高效。 
 但是上面的代码没有考虑类拷贝的问题，大家参照上面的类拷贝问题可以自己把函数加上，然后去试一试，有问题可以留言大家一起解决~