下面分两个部介绍static关键字的使用：
（1）普通变量和成员函数
（2）类中的作用

1 普通的变量和成员函数

1.1 静态全局变量

#include <iostream>

using namespace std;
void fun();
static int n;
int main()
{
    n = 20;
    cout << n << endl;
    fun();
}

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

输出：

20
21

注意：

未经初始化的静态全局变量会被程序自动初始化为0
静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的
静态变量都在全局数据区分配内存，包括后面将要提到的静态局部变量
下面演示在静态全局变量不能被其它文件所用：
主程序 main.cpp：

#include <iostream>
#include "fun.h"
using namespace std;
void fn();
static int n;
int main()
{
    n = 20;
    cout << n << endl;
    f();
}

fun.cpp：

#include "fun.h"
#include <iostream>
using namespace std;
extern int n;
void f()
{
    n++;
    cout << n << endl;
}

fun.h：

#ifndef __FUN_H__
void f();
#endif // __FUN_H__

这个程序在运行的过程中会出现错误，就是因为静态全局变量不能被其它文件所用，这里只需要将主文件中将static关键字去掉就可以运行了。
注意：全局变量和全局静态变量的区别

全局变量是不显式用static修饰的全局变量，全局变量默认是有外部链接性的，作用域是整个工程，在一个文件内定义的全局变量，在另一个文件中，通过extern 全局变量名的声明，就可以使用全局变量。
全局静态变量是显式用static修饰的全局变量，作用域是声明此变量所在的文件，其他的文件即使用extern声明也不能使用。

1.2 静态局部变量

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

#include <iostream>

using namespace std;
void fun();
int main()
{
    fun();
    fun();
    fun();
    return 0;
}

void fun()
{
    static int a = 10;
    cout << a << endl;
    a++;
}

输出：

10
11
12

静态局部变量有以下特点：

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

1.3 静态函数

在函数的返回类型前加上static关键字，函数即被定义为静态函数。静态函数与普通函数不同，与静态全局变量类似，它只能在声明它的文件当中可见，不能被其它文件使用。
下面通过三个文件来进行说明：
main.cpp

#include <iostream>
#include "f.h"
using namespace std;

int main()
{
    fun();
    return 0;
}

f.cpp

#include <iostream>
#include "f.h"
using namespace std;

int main()
{
    fun();
    return 0;
}

f.h

#ifndef __F__H__
static void fun();
#endif // __F__H__

这个程序在运行过程中也是错误的，原因也就是在f.h文件中用static声明了fun()函数。

2 在类中的作用

2.1 静态数据成员

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

#include <iostream>
using namespace std;

class Numbers
{
public:
    Numbers(int a, int b, int c);
    int Getadd();

private:
    int a;
    int b;
    int c;
    static int Sum;
};
int Numbers::Sum = 0;

Numbers::Numbers(int a, int b, int c)
{
    this->a = a;
    this->b = b;
    this->c = c;
}

int Numbers::Getadd()
{
    Sum = a+b+c;
    return Sum;
}

int main()
{
    Numbers N(1,2,3);
    cout << N.Getadd() << endl;;

    return 0;
}

输出：

静态数据成员具有以下特点：

静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义
静态数据成员和普通数据成员一样遵从public,protected,private访问规则
因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以，它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它
静态数据成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式为：
<数据类型><类名>::<静态数据成员名>=<值>
类的静态数据成员有两种访问形式：
<类对象名>.<静态数据成员名> 或 <类类型名>::<静态数据成员名>

2.2 静态成员函数

与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。普通的成员函数一般都隐含了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this 是缺省的。如上一个函数Getadd()实际上是this->Getadd()。但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数

#include <iostream>
using namespace std;

class Numbers
{
public:
    Numbers(int a, int b, int c);
    static int Getadd();

private:
    int a;
    int b;
    int c;
    static int Sum;
};
int Numbers::Sum = 0;

Numbers::Numbers(int a, int b, int c)
{
    this->a = a;
    this->b = b;
    this->c = c;
    // 这里并不是访问类的私有成员，参数传递的值
    Sum = a+b+c;
}
// 静态成员函数只能访问静态成员变量
int Numbers::Getadd()
{
    // 设置Sum是static变量就不能再访问类中的私有成员
    // Sum = a+b+c;
    // cout << a << endl;
    return Sum;
}

int main()
{
    // 静态成员函数为类所共享
    Numbers N1(1,2,3);
    cout << N1.Getadd() << endl;
    Numbers N2(2,2,2);
    cout << Numbers::Getadd() << endl;

    return 0;
}

输出：

6
6

关于静态成员函数，可以总结为以下几点：

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

C++基础-static关键字