单实例设计模式和常量数据成员，常量成员函数，常对象是什么

单实例设计模式 一：什么是设计模式

套路，解决问题的惯用方法，不同语言实现的方式不一样，但是思想是一样的，目前公认的设计模式有23种

二：什么是单实例设计模式

设计模式之一，保证系统中应用这个模式类只有一个实例对象，也就是通过这个单实例设计模式写一个C++的类，然后用这种方法写出的类

永远只有一个实例化对象，在程序中，最多只能存一个实例对象，最少可以没有实例化对象，就算用这个类去创建对象，也只能创建一个对象

使用c++实现单例模式

想办法让类只能创建一个对象（思路：直接弄行不通，可以试试曲线救国）

三：实现单实例设计模式

类应该怎么写才能保证只有一个对象呢，一步到位是不可能的，我们现在对于一个普通的类来讲，可以创建很多个对象，那么我们先把这个权限关闭了，把构造函数变为私有的：private
有一个私有的构造函数，并且没有公有的构造函数的情况下，你的对象任何一个都没有办法去创建了，因为函数在类外访问不到了而创建对象必须在类外创建，但是任何对象都创建不了，肯定是不行的

#include
using namespace std;
class SingleInstance//singleinstance翻译是单实例的意思
{
public:
    ~SingleInstance();
private:
    SingleInstance();
};

现在构造函数变为私有的就一个对象都创建不了了，这是肯定不行的，那么就提供一个公有方法去调用构造函数

#include
using namespace std;
class SingleInstance//singleinstance翻译是单实例的意思
{
public:
    ~SingleInstance();
    void getobj()
    {
        SingleInstance();//但是如果写上这行代码之后，就会出现两个问题
    }
private:
    SingleInstance();
};

第一个问题就是这样的普通函数需要对象才能访问，那么这个好解决加个static，变成静态函数，可以不用对象去访问了，可以用类名直接访问：static void getobj()
那么下一个问题:你是不是可以无限次的用类名去访问这个静态函数了。

既然能无限访问，就能无限去调用静态函数成员中的普通构造函数那么就能无限创建对象，好像这样也不行
但是如果进一步的做出一点点改变，怎么样去保证一种事情只可以做一次呢，那么咱们能不能找到一个只会执行一次的东西呢，这个时候你想到static修饰的静态成员，只能初始化一次

#include
using namespace std;
class SingleInstance
{
public:
    ~SingleInstance();
    static SingleInstance*getInstance()
    {
        return pInstance();
    }
private:
    SingleInstance();
    static SingleInstance*pInstance;
};
SingleInstance*SingleInstance::pInstance = new SingleInstance;

构造函数这条路封死了，还要去防一手拷贝构造函数

 

#include
using namespace std;
class SingleInstance
{
public:
    ~SingleInstance()
    {
        delete pInstance;
        pInstance = NULL;
    }
    static SingleInstance*getInstance()
    {
        return pInstance();
    }
private:
    SingleInstance(){};
        ;
        SingleInstance(const SingleInstance&ref){}
        static SingleInstance*pInstance;
    }
SingleInstance*SingleInstance::pInstance = new SingleInstance;
int main()
{
    SingleInstance*p_obj = NULL;
    for (size_t i = 0; i < 20; i++)
    {
        p_obj = SingleInstance::getInstance();
        cout << hex << "当前对象的首地址： OX" << p - obj << endl;
    }
    return 0;
}

四：常量数据成员：

定义：在C++类中声明成员时加上const关键字

代码举例：

class ClassName
{
    const Type date;
};

const int val这就是一个常量数据成员

五:常量数据成员的特点：

一：可以在类中声明的时候直接给初始值（尽量不要怎么做）

Class ClassName
{
    const Type date = 0;//尽量不要这样做
}

二：可以使用成员初始化列表
 

ClassName::ClassName()
:val(0)
{

}

总之必须初始化

六：常量成员函数

一：可以直接在类中定义
二：可以在类中声明再类外定义  注意：const
注意：const是加到函数名的后面的
 

void test_Func_1()const;//类中声明
void test_Func_1()const//直接在类中定义
{

};

调用的时候也必须在函数名后面加const，加const和不加的完全就是两个不同的函数,甚至这两个函数还可以构成重载，所以构成重载的条件也可以算上const 

void ClassName::test_Func_1()const
{

}

常量成员函数简称常成员

七：常量成员函数的特点

一：函数中不能对自身变量进行修改

二：只要是能用this指针所指向的所有数据都不可以被修改
三：静态数据可以改变

四：可以用来帮助我们来限定自身来调用这个函数修改自身的数据
 

void ClassName::test_Func_1()const
{
    num;
    this->num;
    num = 0;
    this->num = 0;//这样写就会报错，因为this指向的不能改变，改值是做不到的，但是访问可以，也就是能用但是不能改
}

八：常对象：

特点：一：对象实例化的时候在类名前面加上const修饰

const ClassName obj;//这样就行了，这就是一个常对象

二：该对象为常量对象，满足常量的 *** 作，声明时必须初始化；只要是常量都必须初始化。

三：该对象所有数据都不能被修改//这也是必须要初始化的一个原因
四：该对象不允许调用普通成员函数，只允许调用常量成员函数//原因是由于常对象的值不能被修改，但是你又不能保证调用的普通成员函数不会 修改它的数据，所以说只允许常对象去调用绝对不会修改成员数据的常成员函数
代码举例：
 

比如test_fun_3(); 是一个普通的函数成员，
obj.test_fun_3();//像这样常对象去调用普通函数是会报错的，为的就是保证绝对不会去修改任何东西