【2020.12.28】static关键字

面向过程设计中的static(C语言)

"私有"的全局变量。

void Function(int nFlag)
{
    //只能给当前函数使用的全局变量
    static char szBuffer[0x10];

    if(nFlag)
    {
        strcpy(szBuffer, "Hello");
    }
    else
    {
        printf("%s\n", szBuffer);
    }
}

//只能给当前函数使用，所以是"私有"的全局变量。

static char szBuffer[0x10];

全局变量的特点

1. 放在全局区(静态区)，程序启动时就已经有了。
2. 一个地方修改全局变量，在其他地方读取都会是修改后的结果。

其他作用

文件

//test.h

//声明给其他地方使用
extern void Print();

//test.cpp

#include <iostream>
#include "test.h"

void Print()
{
	printf("Hello World!\n");
}

声明为extern

//main.cpp

#include "test.h"

int main()
{
    Print();

    return 0;
}

声明为static

//test.h

//声明给其他地方使用
extern void Print();

//test.cpp

#include <iostream>
#include "test.h"

static void Print()
{
	printf("Hello World!\n");
}

1. 只在当前文件中有效，哪怕头文件中声明为extern，其他地方也无法使用。
2. 函数前的extern可以省略，而变量前的extern不能省略。

面向过程设计中static的作用(C语言)

"私有"的全局变量，在局部变量前加上static，该局部变量的性质被改变，成为了全局变量，且只有当前函数可以使用。

在文件中定义了函数或全局变量，不希望其他文件使用定义的函数或全局变量，即可使用static修饰。

面向对象设计中的static(C++)

• 静态数据成员储存在全局数据区，且必须初始化，静态数据成员初始化的格式为：
• <数据类型><类名>::<静态数据成员名>=<值>

• 静态数据成员和普通数据成员一样遵从public、protected、private访问规则。

• 类的静态数据成员有两种访问形式：

1. <类对象名>.<静态数据成员名>
2. <类类型名>::<静态数据成员名>

• 同全局变量相比，使用静态数据成员有两个优势：

1. 避免命名冲突。
2. 可以实现信息隐藏。

#include <iostream>

class Base
{
private:
    int x;
    int y;

    //只有当前类(Base)才可以使用的全局变量
    //但是不属于Base，仅仅是Base可以使用的全局变量
    static int z;
};

//静态成员初始化
//<数据类型><类名>::<静态数据成员名>=<值>
int Base::z = 0;

int main(int argc, char* agrv[])
{
    return 0;
}

使用static修饰成员函数

被static修饰的成员函数称为静态成员函数。

#include <iostream>

class Base
{
private:
    int x, y;

    //声明静态数据成员
    static int Sum;

public:
    Base(int x, int y);

    //声明静态成员函数
    static int GetSum();
};

//定义并初始化静态成员
int Base::Sum = 0;

//定义构造函数
Base::Base(int x, int y)
{
    this->x = x;
    this->y = y;
}

//定义静态成员函数
int Base::GetSum()
{
    return Sum;
}

int main(int argc, char* agrv[])
{
    //可以在不创建对象的情况下直接访问
    Base::GetSum();

    return 0;
}

面向对象设计中的static之静态成员函数

• 出现在类体外的函数定义不能指定关键字static。
• 静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数。
• 非静态成员函数可以任意地访问静态成员函数和静态数据成员。
• 静态成员函数不能访问非静态成员函数和非静态数据成员。
• 调用类的静态成员函数的两种方式：

1. <类名>::<静态成员函数名>(<参数列表>)
2. <对象名称>.<静态成员函数名>(<参数列表>)
3. <指针>-><静态成员函数名>(<参数列表>)

static关键字的经典应用：单子模式

有些时候我们希望定义的某些类只能有且只有一个对象存在(因为一个对象就已经足够了)，该如何进行限制呢？

实现思路：

1. 禁止对象随便被创建。
2. 保证对象只有一份存在。

#include <iostream>

class Singleton
{
private:
    //定义静态成员
    static Singleton* m_pInstance;

    //将构造函数设置为private
    //禁止对象随便被创建, 但自己可以访问自己
    Singleton()    {}

public:
    //static修饰后不创建对象也可以使用
    static Singleton* GetInsTance()
    {
        //保证对象只有一份存在
        if(m_pInstance == NULL)
            m_pInstance = new Singleton();
        return m_pInstance;
    }
};

//初始化静态成员
Singleton* Singleton::m_pInstance = NULL;

int main(int argc, char* agrv[])
{
    //static
    Singleton::GetInsTance();

    return 0;
}