C++
的
static
有两种用法：面向过程程序设计中的
static
和面向对象程序设计中的
static
。前者应用于普通变量和函数，不涉及类；后者主要说明
static
在类中的作用。
一、面向过程设计中的
static
1
、静态全局变量
在全局变量前，加上关键字
static
，该变量就被定义成为一个静态全局变量。我们先举一个静态全局变量的例子，如下：
//Example 1
#include <iostream.h>
void fn();
static int n; //
定义静态全局变量
void main()
{
n=20;
cout<<n<<endl;
fn();
}
void fn()
{
n++;
cout<<n<<endl;
}
静态全局变量有以下特点：
-
该变量在全局数据区分配内存；
-
未经初始化的静态全局变量会被程序自动初始化为
0
（自动变量的值是随机的，除非它被显式初始化）；
-
静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的；
静态变量都在全局数据区分配内存，包括后面将要提到的静态局部变量。对于一个完整的程序，在内存中的分布情况如下图：
一般程序的由
new
产生的动态数据存放在堆区，函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间，静态数据（即使是函数内部的静态局部变量）也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间。细心的读者可能会发现，
Example 1
中的代码中将
static int n; //
定义静态全局变量
改为
int n; //
定义全局变量
程序照样正常运行。
的确，定义全局变量就可以实现变量在文件中的共享，但定义静态全局变量还有以下好处：
-
静态全局变量不能被其它文件所用；
-
其它文件中可以定义相同名字的变量，不会发生冲突；
您可以将上述示例代码改为如下：
//Example 2
//File1
#include <iostream.h>
void fn();
static int n; //
定义静态全局变量
void main()
{
n=20;
cout<<n<<endl;
fn();
}
//File2
#include <iostream.h>
extern int n;
void fn()
{
n++;
cout<<n<<endl;
}
编译并运行
Example 2
，您就会发现上述代码可以分别通过编译，但运行时出现错误。试着将
static int n; //
定义静态全局变量
改为
int n; //
定义全局变量
再次编译运行程序，细心体会全局变量和静态全局变量的区别。
注意事项
:
1.
“记忆性”
,
程序运行很重要的一点就是可重复性
,
而
static
变量的
”记忆性”破坏了这种可重复性
,
造成不同时刻至运行的结果可能不同
.
2.
“生存期”全局性和唯一性
.
普通的
local
变量的存储空间分配在
stack
上
,
因此每次调用函数时
,
分配的空间都可能不一样
,
而
static
具有全局唯一性的特点
,
每次调用时
,
都指向同一块内存
,
这就造成一个很重要的问题
----
不可重入性
!!!
2
、静态局部变量
在局部变量前，加上关键字
static
，该变量就被定义成为一个静态局部变量。
我们先举一个静态局部变量的例子，如下：
//Example 3
#include <iostream.h>
void fn();
void main()
{
fn();
fn();
fn();
}
void fn()
{
static n=10;
cout<<n<<endl;
n++;
}
通常，在函数体内定义了一个变量，每当程序运行到该语句时都会给该局部变量分配栈内存。但随着程序退出函数体，系统就会收回栈内存，局部变量也相应失效。
但有时候我们需要在两次调用之间对变量的值进行保存。通常的想法是定义一个全局变量来实现。但这样一来，变量已经不再属于函数本身了，不再仅受函数的控制，给程序的维护带来不便。
静态局部变量正好可以解决这个问题。静态局部变量保存在全局数据区，而不是保存在栈中，每次的值保持到下一次调用，直到下次赋新值。
静态局部变量有以下特点：
-
该变量在全局数据区分配内存；
-
静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化；
-
静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为
0
；
-
它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束；
-
注意事项:
-
-
在多线程程序设计或递归程序设计中, 要特别注意这个问题.
-
(不可重入性的例子可以参见<effective C++ (2nd)>(影印版)第103-105页)
-
下面针对示例程序二, 分析在多线程情况下的不安全性.(为方便描述, 标上行号)
-
① const char * IpToStr(UINT32 IpAddr)
-
② {
-
③ static char strBuff[16]; // static局部变量, 用于返回地址有效
-
④ const unsigned char *pChIP = (const unsigned char *)&IpAddr;
-
⑤ sprintf(strBuff, "%u.%u.%u.%u", pChIP[0], pChIP[1], pChIP[2], pChIP[3]);
-
⑥ return strBuff;
-
⑦ }
-
假设现在有两个线程A,B运行期间都需要调用IpToStr()函数, 将32位的IP地址转换成点分10进制的字符串形式. 现A先获得执行机会, 执行IpToStr(), 传入的参数是0x0B090A0A, 顺序执行完应该返回的指针存储区内容是:”10.10.9.11”, 现执行到⑥时, 失去执行权, 调度到B线程执行, B线程传入的参数是0xA8A8A8C0, 执行至⑦, 静态存储区的内容是192.168.168.168. 当再调度到A执行时, 从⑥继续执行, 由于strBuff的全局唯一性, 内容已经被B线程冲掉, 此时返回的将是192.168.168.168字符串, 不再是10.10.9.11字符串.
这里可以考虑用多线程局部存储（
TLS
）
,
我将在以后写一般关于这方面的文章。
3
、静态函数
在函数的返回类型前加上
static
关键字
,
函数即被定义为静态函数。静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。
静态函数的例子：
//Example 4
#include <iostream.h>
static void fn();//
声明静态函数
void main()
{
fn();
}
void fn()//
定义静态函数
{
int n=10;
cout<<n<<endl;
}
定义静态函数的好处：
-
静态函数不能被其它文件所用；
-
其它文件中可以定义相同名字的函数，不会发生冲突；
范例：
//file1.cpp
static int varA;
int varB;
extern void funA()
{
……
}
static void funB()
{
……
}
//file2.cpp
extern int varB; //
使用
file1.cpp
中定义的全局变量
extern int varA; //
错误
! varA
是
static
类型
,
无法在其他文件中使用
extern vod funA(); //
使用
file1.cpp
中定义的函数
extern void funB(); //
错误
!
无法使用
file1.cpp
文件中
static
函数
二、面向对象的
static
关键字（类中的
static
关键字）
1
、静态数据成员
在类内数据成员的声明前加上关键字
static
，该数据成员就是类内的静态数据成员。先举一个静态数据成员的例子。
//Example 5
#include <iostream.h>
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;
Sum+=a+b+c;
}
void Myclass::GetSum()
{
cout<<"Sum="<<Sum<<endl;
}
void main()
{
Myclass M(1,2,3);
M.GetSum();
Myclass N(4,5,6);
N.GetSum();
M.GetSum();
}
可以看出，静态数据成员有以下特点：
-
对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新；
-
静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义。在
Example 5
中，语句
int Myclass::Sum=0;
是定义静态数据成员；
-
静态数据成员和普通数据成员一样遵从
public,protected,private
访问规则；
-
Static
成员变量的初始话是在类外，此时不能再带上
static
的关键字。
private,protected
的
static
成员虽然可以在类外初始化，但是不能在类外被访问。
-
因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以，它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它；
-
静态数据成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式为：
＜数据类型＞＜类名＞
::
＜静态数据成员名＞
=
＜值＞
-
类的静态数据成员有两种访问形式：
＜类对象名＞
.
＜静态数据成员名＞
或
＜类类型名＞
::
＜静态数据成员名＞
如果静态数据成员的访问权限允许的话（即
public
的成员），可在程序中，按上述格式来引用静态数据成员
；
-
静态数据成员主要用在各个对象都有相同的某项属性的时候。比如对于一个存款类，每个实例的利息都是相同的。所以，应该把利息设为存款类的静态数据成员。这有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局数据区的内存，所以节省存储空间。第二，一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了；
-
同全局变量相比，使用静态数据成员有两个优势：
-
静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其它全局名字冲突的可能性；
-
可以实现信息隐藏。静态数据成员可以是
private
成员，而全局变量不能；
2
、静态成员函数
与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。普通的成员函数一般都隐含了一个
this
指针，
this
指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，
this
是缺省的。如函数
fn()
实际上是
this->fn()
。但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有
this
指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。下面举个静态成员函数的例子。
//Example 6
#include <iostream.h>
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;
}
void main()
{
Myclass M(1,2,3);
M.GetSum();
Myclass N(4,5,6);
N.GetSum();
Myclass::GetSum();
}
关于静态成员函数，可以总结为以下几点：
-
出现在类体外的函数定义不能指定关键字
static
；
-
静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；
-
非静态成员函数可以任意地访问静态成员函数和静态数据成员；
-
静态成员函数不能访问非静态成员函数和非静态数据成员；
-
由于没有
this
指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长；
-
调用静态成员函数，可以用成员访问操作符
(.)
和
(->)
为一个类的对象或指向类对象的指针调用静态成员函数，也可以直接使用如下格式：
＜类名＞
::
＜静态成员函数名＞（＜参数表＞）
调用类的静态成员函数。
三、用法小结
-
static Global variable:
文件作用域：只在声明的文件中有效，其他源文件中不可见；同时有了
static
的生命周期
Global variable:
文件作用域：可以加上
extern
声明为外部变量，跨文件作用域
(
这里指的是把这些变量定义在
.cpp
文件中
)
-
static (Global) Function:
有文件作用域，只在本文件中使用
Global Function:
无文件作用域
-
static Member (in Function) variable:
函数调用完成后，变量保存状态，再次调用函数，不会重新分配空间
Member(in Funcition) variable:
函数内的生命周期
-
static Member(in Class) variable:
属于类范围，
Member(in Class) variable:
属于类派生的特定对象，生命周期和对象一致
Reference:
http://www.vckbase.com/document/viewdoc/?id=1720
http://topic.csdn.net/t/20060414/11/4686455.html
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1788286