C/C++中的static关键字

1. 序言

术语static有着不寻常的历史.
起初，在C中引入关键字static是为了表示退出一个代码块后仍然存在的局部变量。
随后，static在C中有了第二种含义：用来表示不能被其它文件访问的全局变量和函数。为了避免引入新的关键字，所以仍使用static关键字来表示这第二种含义。
最后，C++重用了这个关键字，并赋予它与前面不同的第三种含义：表示属于一个类而不是属于此类的任何特定对象的变量和函数(与Java中此关键字的含义相同)。

而这一历史发展也间接的说明了static的作用：
1）全局生命周期；
2）文件作用域隐藏；
3）类的多个对象之间的数据共享（也可以看做对象通信的一种方式）。

2. 补充知识

2.1 程序的内存分布

对于一个程序而言，在程序读入内存进行执行后，其在内存中的分布可以简要的分为以下五个部分：
1）代码区：顾名思义，存放程序2进制代码的区域，通常，函数的入口地址便是代码区对应的地址，执行函数调用时，根据函数入口地址进行调用；其生命周期随着程序的终止而终止；
2）栈区：存储代码块或者函数中生成的自由变量；其生命周期随着代码块的执行完毕或者函数的执行完毕进行释放；
3）堆区：存储由malloc或者new生成的变量，分别由对应的free和delete删除；其生命周期是new和delete所决定的时间，如果不能用free或者delete正确释放，将会发生内存泄露，其将会在程序终止时进行释放。
4）静态变量和全局变量区：存储程序中的静态变量和全局变量；其在程序入口函数执行调用前进行初始化，在程序终止时进行释放；
5）字符串常量区：存储字符串常量的区域；其中字符串无法进行修改，通常修饰为const char *；其生命周期随程序的终止而终止。

2.2 变量的区分

C语言中的变量可以分为：全局变量、静态全局变量、静态局部变量和局部变量。

区别

(1) 按存储区域分
全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域，局部变量存放在内存的栈区。
(2) 按作用域分
全局变量在整个工程文件内都有效；静态全局变量只在定义它的文件内有效；静态局部变量只在定义它的函数内有效，只是程序仅分配一次内存，函数返回后，该变量不会消失；局部变量在定义它的函数内有效，但是函数返回后失效。

全局变量的声明之前再冠以static就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。

从以上分析可以看出，
把局部变量改变为静态局部变量后是改变了它的存储方式即改变了它的生存期。
把全局变量改变为静态变量后是改变了它的作用域， 限制了它的使用范围。

而C++中的变量在此基础上增加了成员变量和静态成员变量。
1）成员变量属于单个对象所有，其生命期与对象的声明期相同；
2）静态成员变量属于整个类所有，该类的所有对象共享这一份数据，因此，静态成员变量的生命期和类的生命期相同，也即程序的执行周期。并且，静态成员变量先于具体的类对象存在而存在。

3. C语言中的static

C语言中的static，其主要功能集中在其在面向过程设计中的功能，也即全局生命周期和文件作用域。

其主要特点如下：
1) 变量会被放在程序的静态变量和全局变量区存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。通常静态变量会被默认初始化为0.
2) 变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。

3.0 static 作用域测试

示例说明：
1）两个cpp文件中均声明一个static静态变量，两个变量同名，但是处于不同的文件；
2）在main文件中，调用两个变量，进行输出。

第一处静态变量：

// Declare.h
#include "stdafx.h"
int & GetStaticNums();  // 返回静态变量值

// Declare.cpp
#include "stdafx.h"
static int nTestNums = 20;  // 第一处定义
int & GetStaticNums()
{
    return nTestNums;
}

第二处静态变量:

#include "stdafx.h"
#include <stdio.h>
#include "declare.h"

static int nTestNums = 10;  // 第二处定义


int _tmain(int argc, _TCHAR* argv[])
{

    printf("%d---%d", nTestNums, GetStaticNums());  // 依次返回两个静态变量的值
    return 0;
}

上述代码输出：

10---20

上述结果表明，在程序中实际上存在两个同名变量，虽然他们的名字相同，但是由于static的作用，两个变量分处不同的文件，导致编译成.o文件时，真实进行了内存的分配，而不是如同全局变量一样，在链接中会进行重定义的错误提示。
上述结果，也真实的表明，static会限制变量的文件作用域，在一个工程中，可以声明同名的静态变量而不用担心他们之间会导致重定义错误。

3.1 静态全局变量

在全局变量前，加上关键字static，该变量就被定义成为一个静态全局变量。

静态全局变量有以下特点：
• 该变量在静态变量和全局数据区分配内存；
• 未经初始化的静态全局变量会被程序自动初始化为0（自动变量的值是随机的，除非它被显式初始化）；
• 静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的；　

如下示例：

//Example 1
#include <iostream>
using std::cout;
using std::endl;

void fn();
static int n; //定义静态全局变量
int main()
{
    n=20;
    cout<<n<<endl;
    fn();
    return 0；
}

void fn()
{
    n++;
    cout<<n<<endl;
}

上述代码输出：

20
21

代码示例描述了静态全局变量就可以实现变量在文件中的共享，但定义静态全局变量还有以下好处：
• 静态全局变量不能被其它文件所用；
• 其它文件中可以定义相同名字的变量，不会发生冲突；

如果将上述示例代码改为如下：

//Example 2
//File1
#include <iostream>
using std::endl;
using std::cout;
void fn();
static int n; //定义静态全局变量
int main()
{
    n=20;
    cout<<n<<endl;
    fn();
    return 0;
}

//File2
#include <iostream>
using std::endl;
using std::cout;

extern int n;
void fn()
{
    n++;
    cout<<n<<endl;
}

编译并运行Example 2，您就会发现上述代码可以分别通过编译，但链接时时出现以下错误：

error LNK2001: 无法解析的外部符号 "int n" (?n@@3HA)

试着将
static int n; //定义静态全局变量
改为
int n; //定义全局变量

再次编译运行程序，即可实现全局变量的跨文件作用域。

编译器环境：vs2005

3.2 静态局部变量

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

通常，在函数体内定义了一个变量，每当程序运行到该语句时都会给该局部变量分配栈内存。但随着程序退出函数体，系统就会收回栈内存，局部变量也相应失效。但有时候我们需要在两次调用之间对变量的值进行保存。通常的想法是定义一个全局变量来实现。但这样一来，变量已经不再属于函数本身了，不再仅受函数的控制，给程序的维护带来不便。

静态局部变量正好可以解决这个问题。静态局部变量保存在静态变量和全局数据区，而不是保存在栈中，每次的值保持到下一次调用，直到下次赋新值。

静态局部变量有以下特点：
• 该变量在静态变量和全局数据区分配内存；
• 静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化，但是下次使用时，必须进行声明，程序会根据声明找到对应的静态变量，并保存其值；
• 静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0；
• 它始终驻留在静态变量和全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束；

//Example 3
#include <iostream>
using std::endl;
using std::cout;

void fn();
int main()
{
    fn();
    fn();
    fn();
    return 0;
}

void fn()
{
    static int n=10;
    cout<<n<<endl;
    n++;
}

输出：

10
11
12

需要注意的一点：第一次声明静态局部变量时，函数被赋值为10；之后的两次声明仅仅只是告诉编译器，在此函数中要使用静态变量，并不会对其进行赋值。

3.3 静态函数

在函数的返回类型前加上static关键字,函数即被定义为静态函数。
静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。
静态函数的例子：

//Example 4
#include <iostream>
using std::endl;
using std::cout;

static void fn();//声明静态函数
int main()
{
    fn();
    return 0;
}
void fn()//定义静态函数
{
    int n=10;
    cout<<n<<endl;
}

定义静态函数的好处：
• 静态函数不能被其它文件所用；
• 其它文件中可以定义相同名字的函数，不会发生冲突；

4. C++语言中的static

C++中static在保持与C的兼容的基础上，又新添加了其面向对象程序设计层面的功能。
主要可以分为静态数据成员和静态成员函数。

4.1 静态数据成员

在类内数据成员的声明前加上关键字static，该数据成员就是类内的静态数据成员。

先举一个静态数据成员的例子。

//Example 5
#include <iostream>
using std::endl;
using std::cout;

class Myclass
{
public:
    Myclass(int a,int b,int c);
    void GetSum();
private:
    int a,b,c;
    static int Sum;//声明静态数据成员
};
int Myclass::Sum=0;//定义并初始化静态数据成员

Myclass::Myclass(int a,int b,int c)
{
    this->a=a;
    this->b=b;
    this->c=c;
    Myclass::Sum += a+b+c;
}

void Myclass::GetSum()
{
    cout<<"Sum="<<Sum<<endl;
}

int main()
{
    Myclass M(1,2,3);
    M.GetSum();
    Myclass N(4,5,6);
    N.GetSum();
    M.GetSum();
    return 0;
}

输出：

Sum=6
Sum=21
Sum=21

可以看出，静态数据成员有以下特点：
- 对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新，当发生更新时，其他对象便可以使用最新的值，这也是一种对象间进行通信的方式；
- 静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义。在Example 5中，语句int Myclass::Sum=0;是定义静态数据成员；
- 静态数据成员和普通数据成员一样遵从public,protected,private访问规则；
- 因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以，它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它；
- 静态数据成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式为：
＜数据类型＞＜类名＞::＜静态数据成员名＞=＜值＞
- 类的静态数据成员有两种访问形式：
＜类对象名＞.＜静态数据成员名＞ 或 ＜类类型名＞::＜静态数据成员名＞
如果静态数据成员的访问权限允许的话（即public的成员），可在程序中，按上述格式来引用静态数据成员 ；
- 静态数据成员主要用在各个对象都有相同的某项属性的时候。比如对于一个存款类，每个实例的利息都是相同的。所以，应该把利息设为存款类的静态数据成员。这有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局数据区的内存，所以节省存储空间。第二，一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了；
- 同全局变量相比，使用静态数据成员有两个优势：
1)静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其它全局名字冲突的可能性；
2)可以实现信息隐藏。静态数据成员可以是private成员，而全局变量不能；

4.2 静态成员函数

与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。
静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。普通的成员函数一般都隐含了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this是缺省的。如函数fn()实际上是this->fn()。

但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。

下面举个静态成员函数的例子。

//Example 6
#include <iostream>
using std::endl;
using std::cout;

class Myclass
{
public:
    Myclass(int a,int b,int c);
    static void GetSum();//声明静态成员函数
private:
    int a,b,c;
    static int Sum;//声明静态数据成员
};
int Myclass::Sum=0;//定义并初始化静态数据成员

Myclass::Myclass(int a,int b,int c)
{
    this->a=a;
    this->b=b;
    this->c=c;
    Sum+=a+b+c; //非静态成员函数可以访问静态数据成员
}

void Myclass::GetSum() //静态成员函数的实现
{
    // cout<<a<<endl; //错误代码，a是非静态数据成员
    cout<<"Sum="<<Sum<<endl;
}

int main()
{
    Myclass M(1,2,3);
    M.GetSum();
    Myclass N(4,5,6);
    N.GetSum();
    Myclass::GetSum();
    return 0;
}

输出：

Sum=6
Sum=21
Sum=21

关于静态成员函数，可以总结为以下几点：
- 出现在类体外的函数定义不能指定关键字static；
- 静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；
- 非静态成员函数可以任意地访问静态成员函数和静态数据成员；
- 静态成员函数不能访问非静态成员函数和非静态数据成员；
- 由于没有this指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长；
- 调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数，也可以直接使用如下格式：＜类名＞::＜静态成员函数名＞（＜参数表＞）调用类的静态成员函数。

5. 使用

1） C++中静态成员函数的使用：
在Windows编程中，静态成员函数常常被设计为该类维持的线程的入口函数，归具体类所有，通常用CreateThread来调用。
2） C语言中的静态函数的使用
在Windows编程中，静态函数的使用可以作为线程的入口函数，由_beginthread调用，同时，在维持函数的文件作用域时，也常常设计为静态函数。