C++的static有两种用法：面向过程中的static和面向对象中的static。前者应用于普通变量和函数，不涉及类；后者主要说明static在类中的作用。

面向过程的static

全局static变量

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

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

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

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

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

前面已经说过，进程中的内存分布有代码段，初始化数据段，未初始化数据段，堆，栈。静态全局变量如果手动初始化，则它位于初始化数据段，如果没有手动初始化，则会被自动初始化并存于未初始化段。其实单从这方面来考虑，静态全局变量的效果和全局变量一样。不同点在于第三条，定义全局变量可以实现变量在文件中的共享，但定义静态全局变量还有以下好处：

静态全局变量不能被其它文件所用；
其它文件中可以定义相同名字的变量，不会发生冲突；

也就是说，如果在一个文件中定义了一个静态全局变量，如果在另一个文件中用extern进行声明，那么在编译时不会报错，但是在执行时会出错。

局部static变量

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

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

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

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

在函数中定义的局部变量会被保存到该函数所在的栈帧中，当函数结束时，栈帧弹出，局部变量失效。但是当定义成局部静态变量可以避免这种情况，因为它被保存到全局数据区，而不是保存在栈中，每次的值保持到下一次调用，直到下次赋新值，程序运行结束时它自动销毁。需要注意的是：虽然保存在全局数据区，但是它只能被该函数访问。

这样的效果其实使用形参也可以实现，但是使用局部静态变量可以省去传参赋值的过程，效率更高。

static函数

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

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

定义静态函数的特点：

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

面向对象的static

static数据成员

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

#include<iostream>
using namespace std;
class Myclass
{
public:
	Myclass(int _a,int _b,int _c):a(_a),b(_b),c(_c){
		Sum += a +b +c;
	}
	void GetSum();
private:
	int a,b,c;
	static int Sum;//声明静态数据成员
};
int Myclass::Sum=0;//定义并初始化静态数据成员
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();
}

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

对于非静态数据成员，每个类的对象都有一份拷贝，而静态数据成员被当做是类的成员，无论产生多少个对象，都只有一份拷贝。也就是说，类的静态数据成员是所有对象所共有的，定义时只分配一次内存，它为所有对象所共有，所以，静态数据成员的值对每个对象都是一样的。
静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义。
静态数据成员和普通数据成员一样遵从public,protected,private访问规则；
因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以，它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时就可以操作它。也就是说可以通过对象来对静态数据成员进行访问（＜类对象名＞.＜静态数据成员名＞），也可以使用类名来进行访问（＜类类型名＞::＜静态数据成员名＞）。
静态数据成员主要用在各个对象都有相同的某项属性的时候。比如银行系统的利息数据成员。

这里有一个问题：为什么类的静态数据成员必须在类内声明，类外定义和初始化
查阅各种博客和资料后，总结如下：

static数据成员在类外定义和初始化是为了保证只被定义和初始化一次,这样编译器就不必考虑类的函数里面第一个对static变量的’=’操作是赋值还是初始化了。

因为被static声明的类静态数据成员，其实体远在main()函数开始之前就已经在全局数据段中诞生了，其生命期和类对象是异步的，（而且即使没有类实体的存在,其静态数据成员的实体也是存在的）这个时候对象的生命期还没有开始，如果你要到类中去初始化类静态数据成员,让静态数据成员的初始化依赖于类的实体,，那么如果类没有实例化，静态数据成员就不能进行访问，显然不满足静态语义。

static成员函数

在成员函数的声明时加上static关键字，该成员函数就成为了静态成员函数。

#include<iostream>
using namespace std;
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();    //6
	Myclass N(4,5,6);
	N.GetSum();    //21
	Myclass::GetSum();    //21
}

和静态数据成员类似，静态成员函数可以服务所有的类对象而不是具体某个类对象。普通成员函数都有一个隐含的this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。由于静态成员函数不是与任何的对象相联系，所以它没有this指针。也就是说，静态成员函数不能访问类的非静态数据成员，也不能调用类的非静态成员函数，它只能访问类的静态数据成员和类的静态成员函数。
静态成员函数有以下特点：

在类外定义时不能有static关键字（可以在类内径进行定义）。
非静态成员函数可以访问静态成员函数和静态数据成员，但是静态成员函数不能访问非静态成员函数和非静态数据成员。
可以使用对象访问静态成员函数，也可以使用类名进行访问。
由于没有this指针的开销，所以类的静态成员函数的运行比类的普通成员函数效率略高。

参考资料
C++中的static关键字的总结
 c++中static的用法详解
 为什么static数据成员一定要在类外初始化?
为什么static数据成员一定要在类外初始化?