C++ static关键字在类中的扩展

static

C++扩展了 static 在类中的语意，用于实现在同一个类，多个对象中共享数据，协
调行为的目的。

静态变量有全局变量的优势，又不会像全变量一样被滥用。而用于管理静态变量，
就需要用到静态函数。

类的静态成员，属于类，也属于对象，但终归属于类。

#include <iostream>
using namespace std;

//static 修饰的数据成员,需要初始化,不可以类内初始化
//类外初始化,需要类名空间,且,不需要static
//类的声明与实现分开的时候,初始化在 .cpp中
//static 声明的数据成员,不占用类对象的大小,存储在data rw段
//没有对象,也可以使用类名 A直接访问share_ 

class A{

    public:
    int  m_ , n_ ;
    static int share_ ; //声明
    //static int share_ =100 ;//错误

};
int A::share_=100; //完成初始化正常执行

int main()
{
        A a;
        cout<<a.n_<<endl;
        cout<<a.m_<<endl;
        cout<<a.share_<<endl; //未初始化会报错
        cout<< sizeof(a)<<endl;
        return 0;
}

static 修饰函数

为了管理静态成员，C++提供了静态函数，以对外提供接口。并且静态函数只能访
问静态成员。

#include <iostream>
using namespace std;

//static 修饰的成员函数,主要用来管理静态变量
//静态成员函数,只能访问静态的成员,不能访问非静态的成员
//是因为,静态成员函数中没有this指针
//非静态函数,是可以访问静态的成员
class A{
public:
    // 静态成员函数manageA，用于管理静态变量
    static void manageA();

    // 静态成员函数manageB，用于管理静态变量
    static void manageB();

    // 非静态成员函数foo，可以访问静态成员和非静态成员
    void foo(){
        cout << a << endl;  // 输出静态成员变量a的值
        manageA();          // 调用静态成员函数manageA
        manageB();          // 调用静态成员函数manageB
    }

private:
    // 静态成员变量a，属于类A，不属于任何特定的对象
    static int a;

    // 非静态成员变量_x，属于类的特定对象
    int _x;
};

// 初始化静态成员变量a，赋值为100
int A::a = 100;

// 定义静态成员函数manageA
void A::manageA(){
    cout << a << endl;  // 输出静态成员变量a的值
    //cout << _x << endl; // 不能访问非静态成员变量_x
    manageB();          // 可以调用静态成员函数manageB
}

// 定义静态成员函数manageB
void A::manageB(){
    cout << a << endl;  // 输出静态成员变量a的值
}

int main(){
    // 创建类A的对象a
    A a;

    // 调用对象a的非静态成员函数foo
    a.foo();

    // 通过对象a调用静态成员函数manageA
    a.manageA();

    // 通过对象a调用静态成员函数manageB
    a.manageB();

    // 通过类名A直接调用静态成员函数manageA
    A::manageA();

    // 通过类名A直接调用静态成员函数manageB
    A::manageB();

    return 0;
}

static
1 静态成员函数的意义，不在于信息共享，数据沟通，而在于管理静态数据成员，完
成对静态数据成员的封装。
2 staitc 修饰成员函数，仅出现在声明处，不可在定义处。
3 静态成员函数只能访问静态数据成员。原因：非静态成员函数，在调用时 this指针
时被当作参数传进。而静态成员函数属于类，而不属于对象，没有 this 指针。

单例模式

单例模式，是一种常用的设计模式，目的是保证一个类只有一个实例，并提供一个全局访问点。

c++
#include <iostream>
#include <stdio.h>
using namespace std;

// 定义一个名为Singleton的类，用于实现单例模式
class Singleton
{
public:
    // 静态成员函数，用于获取单例对象的指针
    static Singleton * getInstance()
    {
        // 如果_ins为NULL，表示单例对象尚未创建
        if(_ins == NULL)
        {
            // 创建一个新的Singleton对象，并将其地址赋值给_ins
            _ins = new Singleton;
            // 返回_ins，即单例对象的指针
            return _ins;
        }
    }

    // 静态成员函数，用于释放单例对象
    static void releaseInstance()
    {
        // 如果_ins不为NULL，表示单例对象已经创建
        if(_ins != NULL)
        {
            // 删除_ins指向的Singleton对象
            delete _ins;
            // 将_ins设置为NULL，表示单例对象已被释放
            _ins = NULL;
        }
    }

private:
    // 私有构造函数，防止外部通过构造函数创建对象
    Singleton(){}

    // 私有析构函数，防止外部通过delete删除对象
    ~Singleton(){}

    // 私有拷贝构造函数，防止对象被拷贝
    Singleton(const Singleton &){}

    // 私有赋值运算符，防止对象被赋值
    Singleton & operator=(const Singleton &){}

    // 静态成员变量，用于存储单例对象的指针
    static Singleton * _ins;
};

// 初始化静态成员变量_ins为NULL
Singleton * Singleton::_ins = NULL;

// 主函数
int main()
{
    // 注释掉的部分，尝试直接创建Singleton对象，但由于构造函数是私有的，会导致编译错误
    // Singleton s;

    // 通过静态成员函数getInstance获取单例对象的指针
    Singleton * ps = Singleton::getInstance();

    // 通过静态成员函数releaseInstance释放单例对象
    Singleton::releaseInstance();

    // 返回0，表示程序正常结束
    return 0;
}

static const in class

如果一个类的成员，既要实现共享，又要实现不可改变，那就用 static const
修饰。修饰成员函数，格式并无二异，修饰数据成员。必须要类内部初始化。

c++
#include <iostream>
using namespace std;

// 定义一个名为A的类
class A
{
public:
    // 定义一个静态常量成员函数dis，返回类型为const static int
    const static int dis()
    {
        // 输出静态常量成员变量i的值
        cout << i << endl;
        // 返回静态常量成员变量i的值
        return i;
    }

private:
    // 定义一个静态常量成员变量i，并初始化为100
    const static int i = 100;
};

int main()
{
    // 通过类名A调用静态成员函数dis，并输出其返回值
    A::dis();
    // 返回0，表示程序正常结束
    return 0;
}