1、将外部链接性的全局变量的链接性限制为内部。大家都知道，在函数外面声明的变量不仅可以在本文件中使用，也可以在其他文件中使用。那么如果我想声明一个变量，只想在本文件的各个函数中使用，不想与其他文件产生关系，那怎么办？用static修饰它就好了，如下：
//A.c文件
int a;//具有外部链接的静态变量，意思就是在其他文件(B,C,D)中也可以使用
static int b;//具有内部链接的静态变量，只可以在文件A中使用
int mian()
{
//一些代码
}
2、修饰函数中的变量，具体过程如下：
#include<iostream>
int count()
{
static int num = 0;//加了static关键字后，num保留上一次的值
num++;
return num;
}
int main()
{
int a;
for (int i = 0; i < 10; i++)
{
count();//调用10次count函数
}
a = count();
std::cout << a << std::endl;
system("pause");
return 0;
}
//结果显示a=11，证明最后一次调用时a的初始值为10，10++之后为11
//若不用static关键字修饰num，那么每次调用count函数都会把num赋值为0
//加了static关键字之后，只有第一次调用count函数时才会给num赋值，以后再调用count函数，num就用上一次保留的值
3、修饰函数。默认情况下，在一个文件中定义的函数，在其他文件中都可以调用。那么我想定义一个只能被本文件中的函数调用，而其它文件不能调用的函数，怎么办？用static修饰它，如下：
//A.cpp
static int function1()//定义
{
//一些代码
}
void function2()
{
function1();//function2可以调用function1,因为它们在同一个文件中
}
//B.cpp
static int function1();
void function2();
void function3()
{
function1();//不OK，function1只能在文件A中用，B文件不能用
function2();//OK,function2没有被static修饰，所以可以在文件B中用
}
4、static修饰类中的变量，如下：
//A.h
#pragma once
class ClassA {
private:
static int num;//所有的成员共用同一个num
public:
ClassA();//构造函数
int getnum() const;//返回num的值
};
//A.cpp
#include"A.h"
int ClassA::num = 0;//注意在这里初始化类中的静态变量，而不是在头文件中初始化
ClassA::ClassA()
{
this->num++;
}
int ClassA::getnum() const
{
return (this->num);
}
//test.cpp
#include<iostream>
#include"A.h"
using namespace std;
int main()
{
ClassA a;
ClassA b;
ClassA c;
cout << "num = " << a.getnum() << endl;
system("pause");
}
//结果 num = 3，说明每创建一个对象，static int num就+1，说明所有对象共用一个static int num
5、static修饰类中的函数
#include<iostream>
using namespace std;
class ClassA {
public:
static void function1();
void function2();
};
void ClassA::function1()//静态函数若要访问类中的数据的话，只能访问静态数据
{ //本函数中没有访问数据，不能演示了
cout << "function1" << endl;
}
void ClassA::function2()
{
cout << "function2" << endl;
}
int main()
{
ClassA::function1();//OK
ClassA::function2();//不OK，必须通过对象调用function2
system("pause");
}
