c++中的static

C++中的static主要有两种用法，第一种是在普通的程序和函数中，第二种是用在类中。两种使用在核心思想上是一致的，但是又有一些地方需要注意。

一、非面向对象的static

  1.声明为全局变量的static

  例子：

 

#include <iostream>
using namespace std;

static int n;   //static global variable

int main()
{
    cout<<n<<endl;
    n = 20;
    cout<<n<<endl;
    return 0;
}

结果输出：

0

20

这里的n就是一个静态全局变量，静态全局变量存放在全局数据区，可以在声明时显示初始化，如果没有显示初始化，则编译器自动初始化为0。静态全局变量在当前文件中可见，但在文件外是不可见的，也就是说，在别的cpp中使用extern int n，是没用的。

2.静态局部变量

静态局部变量，顾名思义，就是声明在局部区域的静态变量。

先看例子：

#include <iostream>
using namespace std;

static int n = 0;   //static global variable

void func()
{
     static int count = 0;   //local global variable
     ++count;
     n += 2;
     cout<<"calls func "<<count<<" times"<<endl;
}


int main()
{
    func();       //1
    func();       //2
    func();       //3
    cout<<"n = "<<n<<endl;
    return 0;
}

运行结果：

calls func 1 times
calls func 2 times
calls func 3 times
n = 6

我们在函数func中定义了一个静态变量，但是这个变量并没有因为函数的执行结束而释放，因为静态的局部变量是存放在全局数据区的，而不是放在栈中的。局部的静态变量，只需在第一次使用的时候初始化（可以不指定初始化值，编译器自动初始化为0），后面将不再进行初始化，因此我们可以看到，虽然每次调用里面都有static int count =0这句，但是真正有效的只是在第一次调用的时候有效。

接下来，把例子稍微改改：

#include <iostream>
using namespace std;

static int n = 0;   //static global variable

void func()
{
     static int count;   //local global variable
     ++count;
     n += 2;
     cout<<"calls func "<<count<<" times"<<endl;
}


int main()
{
    func();       //1
    func();       //2
    func();       //3
    cout<<"n = "<<n<<endl;
    cout<<"count = "<<count<<endl;              //use count in main
    return 0;
}

无法通过编译，原因是在main函数中，count是不可见的，也就是说，虽然局部静态变量存放在全局数据区，但是其作用域仅限于声明它的区域，这里count的声明在func中，因此，只有在func中才能使用count。这一点和全局静态变量也是想通的， 全局的静态变量声明，其作用域也是限制在声明它的区域，也就是当前文件中。

3.static函数

static函数的特点和静态全局变量相似，只在声明它的文件中可见，外部文件不可见。

总结一下非面向对象中的static：

(1)数据存放在全局数据区，但作用域仅限于声明该静态变量的区域；

(2)初始化时可以不指定初始值，编译器自动初始化为0；

(3)由于全局静态变量不可被外部文件所见，因此，如果变量不是必要的需要被外部文件所见，就应该将其声明为static，这样可以防止在不同文件中的变量名的冲突。

二、类中的static

将类中的变量声明为静态的，就是静态成员变量；函数声明为静态的，就是静态成员函数。看一个例子：

#include <iostream>
using namespace std;

class Cls
{
private:
        static int count;
        int val;
public:
       Cls(int v):val(v){}
       void func();
       static void sfunc();
};

int Cls::count = 0;      //defination of count

void Cls::func()
{
     cout<<"val = "<<val<<endl;
     cout<<"calls func "<<++count<<" times."<<endl;
}

void Cls::sfunc()
{
     cout<<"total count = "<<count<<endl;
}

int main()
{
    Cls obj1(10);
    obj1.func();         //1
    obj1.func();         //2
    Cls::sfunc();        //2
    obj1.sfunc();        //2


    Cls obj2(8);
    obj2.func();         //3
    Cls::sfunc();        //3
    obj2.sfunc();        //3
    return 0;
}

输出结果：

val = 10
calls func 1 times.
val = 10
calls func 2 times.
total count = 2
total count = 2
val = 8
calls func 3 times.
total count = 3
total count = 3
 .

在这个例子中，static int count 是类Cls的静态成员变量，static void sfunc()是类的静态成员函数。

静态成员变量属于类，而不属于任何一个对象。因此，所有的类对象都共享一个静态成员，例子中可以看到obj1调用func之后，count被改为2，当obj2来执行func的时候，count直接在原来的基础上修改。而非静态成员，如val，则每一个对象有一个自己的拷贝。

静态成员变量的必须显式的初始化，而且必须在类外，而且不在任何函数中，没有初始化的静态变量是不能被使用的，如果这里去掉了

int Cls::count = 0;  

将会产生编译错误。静态成员的初始化时不用再使用static。

静态成员可以有两种访问方式，直接使用类标号访问，或者使用对象来进行访问。

静态成员函数也是如此静态成员函数只属于类，而不属于任何类对象（没有this指针），这样的一个特点，使得static函数只能访问类的静态成员，而不能访问非静态成员。如果修改一下上面例子中的函数sfunc：

void Cls::sfunc()
{
     cout<<"val = "<<val<<endl;
     cout<<"total count = "<<count<<endl;
}

会报出编译错误，原因是静态成员函数不能访问非静态的成员变量。那能不能在static成员函数中使用非静态的成员函数呢？再来修改喊出sfunc()：

void Cls::sfunc()
{
     func();
     cout<<"total count = "<<count<<endl;
}

仍然报出编译错误： cannot call member function `void Cls::func()' without object，也就是调用非静态的成员函数必须要使用对象来调用，而静态成员函数是没有绑定对象的，因此，也无法调用非静态成员函数。

静态成员函数在类外定义的时候，也不需要指定static关键字。调用static成员函数，需要也有两种方式，通过类标号访问，或者通过类对象访问。 

静态成员函数只能访问非静态成员变量，那么非静态的成员函数能不能访问静态成员变量呢？答案是yes，func()就这么干了。

额外的注意事项（转）：不能将静态成员函数定义为虚函数；