一、static 关键字的几种常见使用
1、静态全局变量
定义在函数体外部的，用于修饰全局，并只在本文件内作用（文件隔离）。
例如：
1 //file a.c
2
3 //static int n = 15; //note:5
4 int n = 15; //note:6
5
6 //file b.c
7 #include <stdio.h>
8
9 extern int n;
10
11 void fn()
12 {
13 n++;
14 printf("after: %d\n",n);
15 }
16
17
18 void main()
19 {
20 printf("before: %d\n",n);
21 fn();
22 }我们先使用note:6,也就是非静态全局变量，发现输出为:
before: 15
after: 16也就是我们的b.c通过extern使用了a.c定义的全局变量。
那么我们改成使用note:5,也就是使用静态全局变量呢？
gcc a.c b.c -o output.out会出现类似undeference to "n"的报错，它是找不到n的，因为static进行了文件隔离，你是没办法访问a.c定义的静态全局变量的，当然你用 #include "a.c",那就不一样了。
以上我们就可以得出静态全局变量的特点：
静态全局变量不能被其它文件所用(全局变量可以);
其它文件中可以定义相同名字的变量，不会发生冲突(自然了，因为static隔离了文件，其它文件使用相同的名字的变量，也跟它没关系了);
2、静态局部变量
定义在函数体内部，使用static关键字修饰，内存上属于全局数据区，这种变量的生存期长于该函数。
当然，对于一个完整的程序，在内存中的分布情况如下：
1.栈区： 由编译器自动分配释放，像局部变量，函数参数，都是在栈区。会随着作用于退出而释放空间。
3.堆区：程序员分配并释放的区域，像malloc(c),new(c++)
3.全局数据区(静态区)：全局变量和静态便令的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束释放。
4.代码区：存放代码块
例子：
1 int foo(){
2 static int i = 1; // note:1
3 //int i = 1; // note:2
4 i += 1;
5 return i;
6 }局部静态变量在函数第一次调用时初始化，并一直存在于静态区，因此它是不会随着调用结束而被销毁，下一次调用也不会再初始化，这是与其他普通局部变量的区别。即生命周期长于函数体。
静态局部变量的特点：
（1）该变量在全局数据区分配内存(局部变量在栈区分配内存);
（2）静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化(局部变量每次函数调用都会被初始化);
（3）静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0(局部变量不会被初始化);
（4）它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，也就是不能在函数体外面使用它(局部变量在栈区，在函数结束后立即释放内存);
3、静态函数
1 //file a.c
2 #include <stdio.h>
3
4
5 void fn()
6 {
7 printf("this is non-static func in a");
8 }
9
10
11 //file b.c
12 #include <stdio.h>
13
14
15 extern void fn(); //我们用extern声明其他文件的fn(),供本文件使用。
16
17
18 void main()
19 {
20 fn();
21 }可以正常输出：this is non-static func in a。
当给void fn()加上static的关键字之后呢？ undefined reference to "fn".
所以，静态函数的好处跟静态全局变量的好处就类似了：
1.静态函数不能被其它文件所用;
2.其它文件中可以定义相同名字的函数，不会发生冲突;
上面一共说了三种用法，为什么说准确来说是两种呢？
1.一种是修饰变量，一种是修饰函数，所以说是两种（这种解释不多）。
2.静态全局变量和修饰静态函数的作用是一样的，一般合并为一种。（这是比较多的分法）。
4、类静态成员变量
用于修饰 class 的数据成员，即所谓“静态成员”。这种数据成员的生存期大于 class 的对象（实体 instance）。静态数据成员是每个 class 有一份，普通数据成员是每个 instance 有一份，因此静态数据成员也叫做类变量，而普通数据成员也叫做实例变量。
1 #include<iostream>
2
3
4 using namespace std;
5
6
7 class Rectangle
8 {
9 private:
10 int m_w,m_h;
11 static int s_sum;
12
13 public:
14 Rectangle(int w,int h)
15 {
16 this->m_w = w;
17 this->m_h = h;
18 s_sum += (this->m_w * this->m_h);
19 }
20
21
22 void GetSum()
23 {
24 cout<<"sum = "<<s_sum<<endl;
25 }
26
27
28 };
29
30
31 int Rectangle::s_sum = 0; //初始化
32
33
34
35
36 int main()
37 {
38 cout<<"sizeof(Rectangle)="<<sizeof(Rectangle)<<endl;
39 Rectangle *rect1 = new Rectangle(3,4);
40 rect1->GetSum();
41 cout<<"sizeof(rect1)="<<sizeof(*rect1)<<endl;
42 Rectangle rect2(2,3);
43 rect2.GetSum();
44 cout<<"sizeof(rect2)="<<sizeof(rect2)<<endl;
45
46 system("pause");
47 return 0;
48 }
由图可知：sizeof(Rectangle)=8bytes=sizeof(m_w)+sizeof(m_h)。也就是说 static 并不占用Rectangle的内存空间。
那么static在哪里分配内存的呢？是的，全局数据区(静态区)。
再看看GetSum()，第一次12=3*4，第二次18=12+2*3。由此可得，static只会被初始化一次，于实例无关。
结论：
对于非静态数据成员，每个类对象(实例)都有自己的拷贝。而静态数据成员被当作是类的成员，由该类型的所有对象共享访问,对该类的多个对象来说，静态数据成员只分配一次内存。
静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义。
也就是说，你每new一个Rectangle，并不会为static int s_sum的构建一份内存拷贝，它是不管你new了多少Rectangle的实例，因为它只与类Rectangle挂钩，而跟你每一个Rectangle的对象没关系。
5、类静态成员函数
1 #include<iostream>
2
3
4 using namespace std;
5
6
7 class Rectangle
8 {
9 private:
10 int m_w,m_h;
11 static int s_sum;
12
13 public:
14 Rectangle(int w,int h)
15 {
16 this->m_w = w;
17 this->m_h = h;
18 s_sum += (this->m_w * this->m_h);
19 }
20
21
22 static void GetSum() //这里加上static
23 {
24 cout<<"sum = "<<s_sum<<endl;
25 }
26
27
28 };
29
30
31 int Rectangle::s_sum = 0; //初始化
32
33
34
35
36 int main()
37 {
38 cout<<"sizeof(Rectangle)="<<sizeof(Rectangle)<<endl;
39 Rectangle *rect1 = new Rectangle(3,4);
40 rect1->GetSum();
41 cout<<"sizeof(rect1)="<<sizeof(*rect1)<<endl;
42 Rectangle rect2(2,3);
43 rect2.GetSum(); //可以用对象名.函数名访问
44 cout<<"sizeof(rect2)="<<sizeof(rect2)<<endl;
45 Rectangle::GetSum(); //也可以可以用类名::函数名访问
46
47
48 system("pause");
49 return 0;
50 }上面注释可见:对GetSum()加上static，使它变成一个静态成员函数，可以用类名::函数名进行访问。
那么静态成员函数有特点呢？
1.静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数;
2.非静态成员函数可以任意地访问静态成员函数和静态数据成员;
3.静态成员函数不能访问非静态成员函数和非静态数据成员;
4.调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数,也可以用类名::函数名调用(因为他本来就是属于类的，用类名调用很正常)
前三点其实是一点：静态成员函数不能访问非静态(包括成员函数和数据成员)，但是非静态可以访问静态，有点晕吗？没关系，我给你个解释，
因为静态是属于类的，它是不知道你创建了10个还是100个对象，所以它对你对象的函数或者数据是一无所知的，所以它没办法调用，而反过来，你创建的对象是对类一清二楚的(不然你怎么从它那里实例化呢)，所以你是可以调用类函数和类成员的，就像不管GetSum是不是static，都可以调用static的s_sum一样。
二、const关键字几种常见使用
·1、修饰普通类型变量
1 const int a = 7;
2 int b = a; // 正确
3 a = 8; // 错误，不能改变a 被定义为一个常量，并且可以将 a 赋值给 b，但是不能给 a 再次赋值。对一个常量赋值是违法的事情，因为 a 被编译器认为是一个常量，其值不允许修改。
2、修饰指针变量
const 修饰指针变量有以下三种情况。
- A: const 修饰指针指向的内容，则内容为不可变量。
1 const int *p = 8;B: const 修饰指针，则指针为不可变量。
1 int a = 8;
2 int* const p = &a;
3 *p = 9; // 正确
4 int b = 7;
5 p = &b; // 错误C: const 修饰指针和指针指向的内容，则指针和指针指向的内容都为不可变量。
1 int a = 8;
2 const int * const p = &a;对于 A，B，C 三种情况，根据 const 位于 * 号的位置不同，我总结三句话便于记忆的话："左定值，右定向，const修饰不变量"。
3、const修饰参数传递和函数返回值
对于 const 修饰函数参数可以分为三种情况。
A：值传递的 const 修饰传递，一般这种情况不需要 const 修饰，因为函数会自动产生临时变量复制实参值。
1 #include<iostream>
2
3 using namespace std;
4
5 void Cpf(const int a)
6 {
7 cout<<a;
8 // ++a; 是错误的，a 不能被改变
9 }
10
11 int main(void)
12
13 {
14 Cpf(8);
15 system("pause");
16 return 0;
17 }B：当 const 参数为指针时，可以防止指针被意外篡改。
1 #include<iostream>
2
3 using namespace std;
4
5 void Cpf(int *const a)
6 {
7 cout<<*a<<" ";
8 *a = 9;
9 }
10
11 int main(void)
12 {
13 int a = 8;
14 Cpf(&a);
15 cout<<a; // a 为 9
16 system("pause");
17 return 0;
18 }C：自定义类型的参数传递，需要临时对象复制参数，对于临时对象的构造，需要调用构造函数，比较浪费时间，因此我们采取 const 外加引用传递的方法。
并且对于一般的 int、double 等内置类型，我们不采用引用的传递方式。
1 #include<iostream>
2
3 using namespace std;
4
5 class Test
6 {
7 public:
8 Test(){}
9 Test(int _m):_cm(_m){}
10 int get_cm()const
11 {
12 return _cm;
13 }
14
15 private:
16 int _cm;
17 };
18
19
20
21 void Cmf(const Test& _tt)
22 {
23 cout<<_tt.get_cm();
24 }
25
26 int main(void)
27 {
28 Test t(8);
29 Cmf(t);
30 system("pause");
31 return 0;
32 }对于const修饰函数返回值分三种情况
A：const 修饰内置类型的返回值，修饰与不修饰返回值作用一样。
1 #include<iostream>
2
3 using namespace std;
4
5 const int Cmf()
6 {
7 return 1;
8 }
9
10 int Cpf()
11 {
12 return 0;
13 }
14
15 int main(void)
16 {
17 int _m = Cmf();
18 int _n = Cpf();
19
20 cout<<_m<<" "<<_n;
21 system("pause");
22 return 0;
23 }B: const 修饰自定义类型的作为返回值，此时返回的值不能作为左值使用，既不能被赋值，也不能被修改。
C: const 修饰返回的指针或者引用，是否返回一个指向 const 的指针，取决于我们想让用户干什么。
4、const修饰类成员函数
const 修饰类成员函数，其目的是防止成员函数修改被调用对象的值，如果我们不想修改一个调用对象的值，所有的成员函数都应当声明为 const 成员函数。
注意：const 关键字不能与 static 关键字同时使用，因为 static 关键字修饰静态成员函数，静态成员函数不含有 this 指针，即不能实例化，const 成员函数必须具体到某一实例。
下面的 get_cm()const; 函数用到了 const 成员函数：
1 #include<iostream>
2
3 using namespace std;
4
5 class Test
6 {
7 public:
8 Test(){}
9 Test(int _m):_cm(_m){}
10 int get_cm()const
11 {
12 return _cm;
13 }
14
15 private:
16 int _cm;
17 };
18
19
20
21 void Cmf(const Test& _tt)
22 {
23 cout<<_tt.get_cm();
24 }
25
26 int main(void)
27 {
28 Test t(8);
29 Cmf(t);
30 system("pause");
31 return 0;
32 }如果 get_cm() 去掉 const 修饰，则 Cmf 传递的 const _tt 即使没有改变对象的值，编译器也认为函数会改变对象的值，所以我们尽量按照要求将所有的不需要改变对象内容的函数都作为 const 成员函数。
参考链接：https://www.runoob.com/w3cnote/cpp-const-keyword.html
