C++ 小探static关键字

static为静态的意思，在C语言中就有这个关键字了，其修饰的变量相对于普通变量存储在栈区而言，存储在了全局变量区，从而静态变量不会随着作用域而释放。
C++中对于static的使用可以分为两种情况，分别为面向过程程序设计与面向对象程序设计场景，下面就分别对这两种情况进行讨论。

I、面向过程中的static

1.1 静态全局变量

在全局变量前，加上static关键字，该变量就被定义为了一个静态全局变量，静态全局变量具有以下特点： 静态全局变量在声明它的整个文件都是可见的，而在文件之外时是不可见的。
正因为上面的特点，静态全局变量与普通全局变量的区别在于：静态全局变量不能被其他文件所使用；其他文件中可以定义相同名字的变量，不会产生冲突（这是因为即便是其他文件使用了已经定义的静态全局变量，只是在自己空间内新开辟了一个新的内存区域，已经不与原来的静态全局变量共享内存，改变其值彼此不受影响。），如下面的简单例子：

测试1：static全局变量的新开辟空间特性

/***********static_head.h**********/
#include
#include
using namespace std;
static string str = "12345";

void fun();

/***********static_head.cpp**********/
#include "static_head.h"


void fun() {
     cout<< str <

/***********test1.h**********/
void fun1();

/***********test1.cpp**********/
#include "test1.h"
#include "static_head.h"

void fun1() {
     fun();

     str = "abcde";
     cout<< str <

/***********test2.h**********/
void fun2();

/***********test2.cpp**********/
#include "test2.h"
#include "static_head.h"

void fun2() {
     cout<< str <

/*main.cpp*/
#include "test1.h"
#include "test2.h"

int main()
{
    fun1();
    fun2();

    return 0;
}

测试1输出结果：

测试1输出结果

可以看出，如果全局静态变量随着其他文件而变化，fun2()也应该输出abcde，由此可见，上面的结论；
而如果将static改为extern，则会报错重复定义str。

1.2 静态局部变量

在局部变量前，加上关键字static，该变量就被定义为了静态局部变量。

静态局部变量具有以下特点：该变量在全局区分配内存；静态局部变量在程序执行到该对象的声明处首次初始化，即便以后的函数调用也不再进行初始化；它将始终驻留在全局数据区，直到程序运行结束。但其作用域是局部作用域，当定义它的函数或语句块结束时，其作用域随之结束。

另外，static局部变量具有记忆性，与生存周期的全局性，见如下例子：

测试2：static的记忆性测试

#include
using namespace std;

void static_localVar()
{
    static int a = 0; //运行到此时初始化，下次运行是不需要再初始化，因为一直保存在全局区
    cout << "a=" << a << endl;
    ++a;
}

int main()
{
    static_localVar();
    static_localVar();
    static_localVar();
    //cout << a << endl;  //error,因为已经离开a的作用域

    return 0;
}

测试2输出结果：

测试2输出结果

1.3 静态函数

在函数的返回类型上加上static关键字，函数就成为了静态函数。静态函数与普通函数不同，它只能在声明它的文件中可见，不能被其他文件所使用。

定义静态函数的好处在于：静态函数不能被其他文件使用；其他文件中可以定义相同名字的函数，不会发生冲突。

II、面向对象的static关键字

面向对象的static关键字即为：类中的static关键字。

2.1 静态数据成员

在类内数据成员的声明前加上关键字static，该数据成员就是类内的静态数据成员。
静态数据成员具有以下特点：
1、相对于非静态数据成员（每个实例都会有一个数据成员的拷贝），静态数据成员在程序中有且仅有一个拷贝，由该类型的实例对象所共享。也就是说，静态数据成员是该类的所有对象共有的。
2、因为静态数据成员在全局区，属于类所有对象共享，所以，它不属于特定的实例，在没有产生类实例的作用域也可见，即，在没有产生类实例时，我们就可以操作它。
3、与全局变量相比，静态数据成员具有两个优势：第一，静态数据成员没有进入程序的全局命名空间，所以不存在与其他名字冲突的可能性，另外一点，静态数据成员可以是private成员，而全局变量不行，从这一方面说，静态数据成员维护了类的封装性。
4、静态数据成员主要用于各个对象具有相同的某项属性的时候，比如说一个存款类，每个实例的利息都是相同的。将其定义为静态数据成员有两个好处：第一内存中只有一份拷贝，节省空间；第二，一旦利息改变，只需要改变静态数据成员即可。

2.2 静态成员函数

1、与静态数据成员一样，我们可以为类创建静态成员函数，它为类的全部实例服务。

2、静态成员函数的this指针是缺省的，这很好理解，因为其并不属于某一个对象；而普通成员函数一般都隐藏了一个指向自身的this指针。

3、因为静态成员函数的this指针是缺省的，所以其没办法访问类的非静态成员函数（联系this指针的作用），只能访问类的静态数据成员和静态成员函数。

4、因为静态成员函数的this指针是缺省的，所以不能将其定义为虚函数，因为虚函数表需要通过this指针访问。同理静态成员变量也无法使用虚函数。

关于静态成员函数与静态数据成员的理解，可以参见C++中一个经典的单例模式实现代码：

/* lazy Singleton */

class Singleton
{
public:
    /* 提供static的Instance()方法，作为全局访问点；
     * 如果有现成的实例，则直接返回；
     *如果没有，则将新生成的实例保存到私有的static属性中
    */
     /* Instance()返回的是实例的引用而不是指针，如果是指针有被外部调用者delete的风险。
      * 直到Instance()方法被访问，才会生成实例，这种特性被称为延迟初始化（Lazy Singleton）
     */
    /* 但是这种方式不是线程安全的，比如有线程A和B
     * 都通过了instance==nullptr判断，则两个线程会分配创建新实例，这样单例模式就被打破了。
    */
    static Singleton& Instance() {
        if (instance == nullptr)
            instance = new Singleton;
        return *instance;
    }

private:
    //构造函数与拷贝构造函数，拷贝赋值运算符都声明为私有方法，这样杜绝从外部生成新的实例
    Singleton();
    ~Singleton();
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);

private:
    static Singleton* instance;
};

关于单例模式，以后会单独写一篇文章

欢迎转载，转载请注明出处：wemmingxing C++小探static关键字