C++之静态成员

静态成员数据

1、静态成员数据 是属于类 而不是对象

2、静态成员数据 是所有对象 共享的

3、静态成员数据 类中定义 类外初始化（不加static）

4、静态成员数据、成员函数 不占类的空间。

class Data
{
public:
    //静态成员数据 是属于类 而不是对象
    //静态成员数据 是所有对象 共享的
    //静态成员数据 类中定义 类外初始化
    static int m_A;//静态成员数据
    int m_B;
};
//类外初始化 静态成员数据(不能加 static)
int Data::m_A = 100;
void test()
{
    //1、直接通过类名称访问静态成员数据(推荐)
    cout<<Data::m_A<<endl;

    //2、通过对象名访问静态成员数据
    Data ob1;
    ob1.m_A = 10;
    Data ob2;
    ob2.m_A = 20;
    cout<<Data::m_A<<endl;
}

静态成员函数

1、静态成员函数 也是属于类 而不是对象（所有对象共享）

2、静态成员函数 只能操作静态成员数据。

class Data
{
private:
    //静态成员数据 是属于类 而不是对象
    //静态成员数据 是所有对象 共享的
    //静态成员数据 类中定义 类外初始化
    static int m_A;//静态成员数据
    int m_B;
public:
    static int getA(void)
    {
        //静态成员函数 只能操作静态成员数据
        //m_B = 200;//err
        return m_A;
    }
};

//类外初始化 静态成员数据(不能加 static)
int Data::m_A = 100;
void test()
{
    //通过类名称访问（推荐）
    cout<<Data::getA()<<endl;

    //通过对象名访问
    Data ob1;
    cout<<ob1.getA()<<endl;
}

静态成员案例

统计类实例化对象的个数

class Data
{
private:
    static int count;
public:
    Data()
    {
        count++;
    }
    Data(const Data &ob)
    {
        count++;
    }
    ~Data()
    {
        count--;
    }
    static int Count(void)
    {
        return count;
    }
};
int Data::count = 0;
void test()
{
    Data ob1;
    Data ob2;
    {
        Data ob3;
        {
            Data ob4;
            Data ob5;
            cout<<Data::Count()<<endl;
        }
        cout<<Data::Count()<<endl;
    }
    cout<<Data::Count()<<endl;
}

int main(int argc, char *argv[])
{
    test();
    cout<<Data::Count()<<endl;
    return 0;
}

单例模式

单例 说的是类只能实例化一个对象。叫单例模式。

#include <iostream>
using namespace std;
class Singleton
{
private:
    //2、定一个静态成员指针保存唯一的对象地址(const 防止更改p的指向)
    static Singleton * const p;

    //1、将所有的构造函数私有化(类外无法实例化对象)
private:
    Singleton(){}
    Singleton(const Singleton &ob){}
public:
    //4、定义静态成员函数 获取唯一的实例地址
    static Singleton * getSingleton(void)
    {
        return p;
    }

    //5、单例模式的功能代码
    void printString(char *str)
    {
        cout<<"打印:"<<str<<endl;
    }

};
//3、类外初始化唯一的实例地址
Singleton * const Singleton::p = new Singleton;

int main(int argc, char *argv[])
{
    Singleton *p1 = Singleton::getSingleton();
    Singleton *p2 = Singleton::getSingleton();
    cout<<p1<<" "<<p2<<endl;
    //0x6324b0 0x6324b0

    return 0;
}