C++简明图解分析静态成员与单例设计模式

class Data
{
public:
    int num;//普通成员变量
    static int data;//静态成员变量(类内声明)
};
//定义的时候 不需要加static
int Data::data=100;//类外定义+初始化
void test01()
{
    //data是静态成员变量 是属于类 可以通过类名称::直接访问
    cout<<Data::data<<endl;//100
    //赋值
    Data::data = 200;
    cout<<Data::data<<endl;//200
    //data静态变量 是所有对象 共享的 可以通过对象名访问
    Data ob1;
    ob1.data = 300;
    cout<<Data::data<<endl;//300
    Data ob2;
    cout<<ob2.data<<endl;//300
    //普通成员变量 属于对象的 只能通过对象名访问
    ob1.num = 100;
    cout<<"ob2.num = "<<ob2.num<<endl;//随机值
    //cout<<Data::num<<endl;//普通成员变量不能通过类名称访问
}

class Data
{
private:
    int num;//普通成员变量
    static int data;//静态成员变量(类内声明)
public:
    //普通成员函数 依赖于 对象的 必须对象调用
    int getData(void)
    {
        return data;
    }
};
//定义的时候 不需要加static
int Data::data=100;//类外定义+初始化
void test01()
{
    //cout<<Data::data<<endl;//err 静态data是私有的 类外不能直接访问
    //cout<< Data::getData()<<endl;//err getData() 必须对象调用
    Data ob;
    cout<<ob.getData()<<endl;
    //存在问题：data静态的 在创建对象之前 就已经存在
    //如果类没有实例化对象 难道 就不能使用data了吗？ 
    //解决上述问题 就要用到静态成员函数
}

class Data
{
private:
    int num;//普通成员变量
    static int data;//静态成员变量(类内声明)
public:
    //普通成员函数 依赖于 对象的 必须对象调用
    int getData(void)
    {
        return data;
    }
    //静态成员函数  属于类 而不属于对象
    static int getDataStatic(void)
    {
        return data;
    }
};
//定义的时候 不需要加static
int Data::data=100;//类外定义+初始化
void test01()
{
    //cout<<Data::data<<endl;//err 静态data是私有的 类外不能直接访问
    //cout<< Data::getData()<<endl;//err getData() 必须对象调用
    Data ob;
    cout<<ob.getData()<<endl;
    //存在问题：data静态的 在创建对象之前 就已经存在
    //如果类没有实例化对象 难道 就不能使用data了吗？
    //解决上述问题 就要用到静态成员函数
    //1、静态成员函数 属于类 就可以通过类名称直接访问
    cout<<Data::getDataStatic()<<endl;
    //2、也可以通过对象名访问（对象共享静态成员函数）
    cout<<ob.getDataStatic()<<endl;
}

class Data
{
public:
    const static int data;//静态成员变量(类内声明)
public:
    //静态成员函数  属于类 而不属于对象
    static int getDataStatic(void)
    {
        //num = 200;//err 静态成员函数 不能访问普通成员变量
        return data;
    }
};
//定义的时候 不需要加static
const int Data::data=100;//类外定义+初始化
void test02()
{
    //访问
    cout<<Data::data<<endl;
    //赋值
    //Data::data = 200;//err data静态成员只读
    cout<<Data::data<<endl;
}

class Data
{
private:
    int data;
    mutable int num;
public:
    //遍历 成员的函数 不会去修改成员的值
    //如果函数不会更改成员数据 就让编译器知道 这是一个const函数
    void myPrintData(void) const
    {
        //data =10000;//err const修饰函数 函数不能操作普通成员变量
        cout<<this->data<<endl;
        //cout<<data<<endl;
        //mutable修饰的成员变量 可以修改
        num = 200;
    }
    //编译器认为 普通成员函数 存在修改成员变量 可能
    void setData(int data) const
    {
        //this->data = data;
        return;
    }
    Data()
    {
        cout<<"无参构造"<<endl;
    }
    Data(int data)
    {
        this->data =data;
        cout<<"有参构造"<<endl;
    }
    Data(const Data &ob)
    {
        this->data = ob.data;
        cout<<"拷贝构造"<<endl;
    }
    ~Data()
    {
        cout<<"析构函数"<<endl;
    }
};
void test03()
{
    //常对象
    const Data ob1(200);
    //常对象 只能调用const修饰的函数 遍历成员数据
    ob1.setData(20000);
    ob1.myPrintData();
}

int myFun(void) const //const修饰的是成员函数
{}//函数内部不能修改 普通成员变量  mutable修饰时例外

class Data2
{
public:
    int a;
    mutable int b;
public:
    Data2(int a, int b):a(a),b(b)
    {
//        this->a = a;
//        this->b = b;
    }
    //const修饰的是整个成员函数 表明在函数内部只能对数据成员 读操作
    void showData2(void) const
    {
        //a=100;//err
        //如果在const修饰的成员函数中 修改成员数据的值 请事先对成员数据进行mutable修饰
        b = 200;//ok
        cout<<"a="<<a<<", b="<<b<<endl;
    }
};
void test02()
{
    Data2 ob(10,20);
    ob.showData2();
}

#include <iOStream>
using namespace std;
class Data
{
public:
    Data()
    {
        cout<<"无参构造"<<endl;
        count++;
    }
    Data(const Data &ob)
    {
        cout<<"拷贝构造函数"<<endl;
        count++;
    }
    ~Data()
    {
        count--;
        cout<<"析构函数"<<endl;
    }
    static int count;
};
int Data::count = 0;
int main(int arGC, char *argv[])
{
    Data ob1;
    Data ob2;
    {
        Data ob3;
        Data ob4;
        cout<<"对象的个数:"<<Data::count<<endl;
    }
    cout<<"对象的个数:"<<Data::count<<endl;
    return 0;
}

#include <iostream>
using namespace std;
class Printer
{
public:
    //2、提供一个方法 获得单例指针
    static Printer* getSignlePrint(void)
    {
        return signlePrint;
    }
    //4、设置功能函数(自定义)
    void printText(char *str)
    {
        cout<<"打印"<<str<<endl;
        count++;
    }
    int count;
private:
    //1、定义一个静态的 对象指针变量 保存唯一实例地址
    static Printer *signlePrint;
private:
    //3、防止 该类实例化其他对象 将构造函数全部 私有
    Printer(){count=0;}
    Printer(const Printer &ob){}
};
Printer *Printer::signlePrint = new Printer;
int main(int argc, char *argv[])
{
    //打印任务1
    Printer *p1 = Printer::getSignlePrint();
    p1->printText("入职报告1");
    p1->printText("体检报告2");
    p1->printText("离职证明3");
    //打印任务2
    Printer *p2 = Printer::getSignlePrint();
    p2->printText("入职报告1");
    p2->printText("体检报告2");
    p2->printText("离职证明3");
    cout<<"打印任务数量:"<<p2->count<<endl;
    return 0;
}