存储类定义 C 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C 程序中可用的存储类：

  • auto
  • register
  • static
  • extern

auto 存储类

auto存储类是所有局部变量默认的存储类

  1. {
  2.    int mount;
  3.    auto int month;
  4. }

⚠️注意: 上面的实例定义了两个带有相同存储类的变量，auto 只能用在函数内，即 auto 只能修饰局部变量

register 存储类

register存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 ‘&’ 运算符（因为它没有内存位置）。

  1. {
  2.    register int  miles;
  3. }

⚠️注意: 寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 ‘register’ 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制

extern 存储类

extern存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用extern时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。
当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用extern来得到已定义的变量或函数的引用。可以这么理解，extern是用来在另一个文件中声明一个全局变量或函数。
extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示：
第一个文件：main.c

  1. #include <stdio.h>
  3. int count ;
  4. extern void write_extern();
  6. int main()
  7. {
  8.    count = 5;
  9.    write_extern();
  10. }

第二个文件：support.c

  1. #include <stdio.h>
  3. extern int count;
  5. void write_extern(void)
  6. {
  7.    printf("count is %d\n", count);
  8. }

在这里，第二个文件中的extern关键字用于声明已经在第一个文件 main.c 中定义的count。现在 ，编译这两个文件，如下所示：

  1.  $ gcc main.c support.c

这会产生a.out可执行程序，当程序被执行时，它会产生下列结果：

  1. count is 5

static 存储类

static存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。
static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。
全局声明的一个 static 变量或方法可以被任何函数或方法调用，只要这些方法出现在跟 static 变量或方法同一个文件中。
以下实例演示了 static 修饰全局变量和局部变量的应用：

  1. #include <stdio.h>
  3. static int globalCount = 10; /* 全局变量 的 static 是默认的 */
  5. /* 函数声明 */
  6. void func(void);
  8. int main()
  9. {
  10.   while (globalCount--)
  11.   {
  12.     func();
  13.   }
  14.   return 0;
  15. }
  17. void func(void)
  18. {
  19.   /* 'localCount' 是 'func' 的局部变量 - 只初始化一次
  20.  * 每次调用函数 'func', 'localCount' 值不会被重置。
  21.  */
  22.   static int localCount = 0;
  23.   int sum = 10;
  24.   sum--;
  25.   localCount++;
  26.   printf(" globalCount 为 %d， localCount 为 %d ，sum 为 %d\n", globalCount, localCount, sum);
  27. }

实例中 count 作为全局变量可以在函数内使用，thingy 使用 static 修饰后，不会在每次调用时重置。
可能您现在还无法理解这个实例，因为我已经使用了函数和全局变量，这两个概念目前为止还没进行讲解。即使您现在不能完全理解，也没有关系，后续的章节我们会详细讲解。当上面的代码被编译和执行时，它会产生下列结果：

  1.  globalCount 为 9， localCount 为 1 ，sum 为 9
  2.  globalCount 为 8， localCount 为 2 ，sum 为 9
  3.  globalCount 为 7， localCount 为 3 ，sum 为 9
  4.  globalCount 为 6， localCount 为 4 ，sum 为 9
  5.  globalCount 为 5， localCount 为 5 ，sum 为 9
  6.  globalCount 为 4， localCount 为 6 ，sum 为 9
  7.  globalCount 为 3， localCount 为 7 ，sum 为 9
  8.  globalCount 为 2， localCount 为 8 ，sum 为 9
  9.  globalCount 为 1， localCount 为 9 ，sum 为 9
  10.  globalCount 为 0， localCount 为 10 ，sum 为 9

C/C++ 中 static 的用法、全局变量与局部变量在内存中的区别

  • 全局变量保存在内存的全局存储区中，占用静态的存储单元
  • 局部变量保存在栈中，只有在所在函数被调用时才动态地为变量分配存储单元

什么是static?

static 是 C/C++ 中很常用的修饰符，它被用来控制变量的存储方式和可见性

static 的引入

我们知道在函数内部定义的变量，当程序执行到它的定义处时，编译器为它在栈上分配空间，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时，如何实现？
最容易想到的方法是定义为全局的变量，但定义一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅只受此函数控制）。static 关键字则可以很好的解决这个问题。
另外，在 C++ 中，需要一个数据对象为整个类而非某个对象服务,同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部，对外不可见时，可将其定义为静态数据。

静态数据的存储

全局（静态）存储区 分为 DATA 段和 BSS 段

  • DATA 段（全局初始化区）存放初始化的全局变量和静态变量
  • BSS 段（全局未初始化区）存放未初始化的全局变量和静态变量。程序运行结束时自动释放。其中BBS段在程序执行之前会被系统自动清0，所以未初始化的全局变量和静态变量在程序执行之前已经为0。存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化

在 C++ 中 static 的内部实现机制：静态数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用，所以静态数据成员不能在任何函数内分配空间和初始化。
这样，它的空间分配有三个可能的地方，

  • 一是作为类的外部接口的头文件，那里有类声明；
  • 二是类定义的内部实现，那里有类的成员函数定义；
  • 三是应用程序的 main() 函数前的全局数据声明和定义处。

静态数据成员要实际地分配空间，故不能在类的声明中定义（只能声明数据成员）。类声明只声明一个类的”尺寸和规格”，并不进行实际的内存分配，所以在类声明中写成定义是错误的。它也不能在头文件中类声明的外部定义，因为那会造成在多个使用该类的源文件中，对其重复定义。
static 被引入以告知编译器，将变量存储在程序的静态存储区而非栈上空间，静态数据成员按定义出现的先后顺序依次初始化，注意静态成员嵌套时，要保证所嵌套的成员已经初始化了。消除时的顺序是初始化的反顺序。
优势: 可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，这样可以提高时间效率。

在 C/C++ 中static的作用

  • 在修饰变量的时候，static 修饰的静态局部变量只执行初始化一次，而且延长了局部变量的生命周期，直到程序运行结束以后才释放。
  • static 修饰全局变量的时候，这个全局变量只能在本文件中访问，不能在其它文件中访问，即便是 extern 外部声明也不可以。
  • static 修饰一个函数，则这个函数的只能在本文件中调用，不能被其他文件调用。static 修饰的变量存放在全局数据区的静态变量区，包括全局静态变量和局部静态变量，都在全局数据区分配内存。初始化的时候自动初始化为 0。
  • 不想被释放的时候，可以使用static修饰。比如修饰函数中存放在栈空间的数组。如果不想让这个数组在函数调用结束释放可以使用 static 修饰。
  • 考虑到数据安全性（当程序想要使用全局变量的时候应该先考虑使用 static）

全局变量和全局静态变量的区别

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

静态全局变量有以下特点

  • 静态全局变量都在全局数据区分配内存，包括后面将要提到的静态局部变量;
  • 未经初始化的静态全局变量会被程序自动初始化为0（在函数体内声明的自动变量的值是随机的，除非它被显式初始化，而在函数体外被声明的自动变量也会被初始化为 0）；
  • 静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的。

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

静态局部变量有以下特点

  • 该变量在全局数据区分配内存；
  • 静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化；静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为 0；
  • 它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束。
  • 一般程序把新产生的动态数据存放在堆区，函数内部的自动变量存放在栈区
    • 自动变量一般会随着函数的退出而释放空间
    • 静态数据（即使是函数内部的静态局部变量）也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间

看下面的例子：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int k1 = 1;
  5. int k2;
  6. static int k3 = 2;
  7. static int k4;
  8. int main()
  9. {
  10.   static int m1 = 2, m2;
  11.   int i = 1;
  12.   char *p;
  13.   char str[10] = "hello";
  14.   char *q = "hello";
  16.   p = (char *)malloc(100);
  17.   free(p);
  19.   printf("栈区-变量地址 i\t\t：%p\n", &i);
  20.   printf("栈区-变量地址 p\t\t：%p\n", &p);
  21.   printf("栈区-变量地址 str\t：%p\n", str);
  22.   printf("栈区-变量地址 q\t\t：%p\n", &q);
  23.   printf("堆区地址-动态申请\t：%p\n", p);
  24.   printf("全局外部有初值 k1\t：%p\n", &k1);
  25.   printf("外部无初值 k2\t\t：%p\n", &k2);
  26.   printf("静态外部有初值 k3\t：%p\n", &k3);
  27.   printf("外静无初值 k4\t\t：%p\n", &k4);
  28.   printf("内静态有初值 m1\t\t：%p\n", &m1);
  29.   printf("内静态无初值 m2\t\t：%p\n", &m2);
  30.   printf("文字常量地址\t\t：%p, %s\n", q, q);
  31.   printf("程序区地址\t\t：%p\n", &main);
  32.   return 0;
  33. }
  35. /* 
  36. 栈区-变量地址 i         ：0x7ffee6588614
  37. 栈区-变量地址 p         ：0x7ffee6588608
  38. 栈区-变量地址 str       ：0x7ffee658861e
  39. 栈区-变量地址 q         ：0x7ffee6588600
  40. 堆区地址-动态申请       ：0x7fbd97c02c60
  41. 全局外部有初值 k1       ：0x109678038
  42. 外部无初值 k2           ：0x10967804c
  43. 静态外部有初值 k3       ：0x109678040
  44. 外静无初值 k4           ：0x109678048
  45. 内静态有初值 m1         ：0x10967803c
  46. 内静态无初值 m2         ：0x109678044
  47. 文字常量地址            ：0x109677e2e, hello
  48. 程序区地址              ：0x109677c20 
  49. */

输出结果如下：
image.png

在 C++ 中static 用法

static 关键字最基本的用法是：

  • 被 static 修饰的变量属于类变量，可以通过 类名.变量名 直接引用，而不需要 new 出一个类来
  • 被 static 修饰的方法属于类方法，可以通过 类名.方法名 直接引用，而不需要 new 出一个类来

被 static 修饰的变量、被 static 修饰的方法统一属于类的静态资源，是类实例之间共享的，换言之，一处变、处处变。
在 C++ 中，静态成员是属于整个类的而不是某个对象，静态成员变量只存储一份供所有对象共用。所以在所有对象中都可以共享它。使用静态成员变量实现多个对象之间的数据共享不会破坏隐藏的原则，保证了安全性还可以节省内存。
静态成员的定义或声明要加个关键 static。静态成员可以通过双冒号来使用即 <类名>::<静态成员名>

通过类名调用静态成员函数和非静态成员函数，报错 ❌

  1. #include <iostream>
  3. class Point
  4. {
  5. public:
  6.   void init()
  7.   {
  8.   }
  9.   static void output()
  10.   {
  11.   }
  12. };
  14. int main()
  15. {
  16.   Point::init();
  17.   Point::output();
  18.   return 0;
  19. }

image.png

  1. 'Point::init' : illegal call of non-static member function

结论 1：不能通过类名来调用类的非静态成员函数

通过类的对象调用静态成员函数和非静态成员函数。编译通过 ✅

  1. #include <iostream>
  3. class Point
  4. {
  5. public:
  6.   void init()
  7.   {
  8.   }
  9.   static void output()
  10.   {
  11.   }
  12. };
  14. int main()
  15. {
  16.   Point pt;
  17.   pt.init();
  18.   pt.output();
  19.   return 0;
  20. }

结论 2：类的对象可以使用静态成员函数和非静态成员函数

在类的静态成员函数中使用类的非静态成员。编译出错 ❌

  1. #include <stdio.h>  
  2. class Point  
  3. {  
  4. public:   
  5.     void init()  
  6.     {    
  7.     }  
  8.     static void output()  
  9.     {  
  10.         printf("%d\n", m_x);  
  11.     }  
  12. private:  
  13.     int m_x;  
  14. };  
  16. void main()  
  17. {  
  18.     Point pt;  
  19.     pt.output();  
  20. }
  1. error C2597: illegal reference to data member 'Point::m_x' in a static member function

image.png
因为静态成员函数属于整个类，在类实例化对象之前就已经分配空间了，而类的非静态成员必须在类实例化对象后才有内存空间，所以这个调用就出错了，就好比没有声明一个变量却提前使用它一样。
结论3：静态成员函数中不能引用非静态成员

在类的非静态成员函数中使用类的静态成员。编译通过✅

  1. #include <iostream>
  3. class Point
  4. {
  5. public:
  6.   void init()
  7.   {
  8.     output();
  9.   }
  10.   static void output()
  11.   {
  12.   }
  13. };
  15. int main()
  16. {
  17.   Point pt;
  18.   pt.init();
  19.   pt.output();
  20.   return 0;
  21. }

结论 4：类的非静态成员函数可以调用用静态成员函数，但反之不能

使用类的静态成员变量。

  1. #include <iostream>
  3. class Point
  4. {
  5. public:
  6.   Point()
  7.   {
  8.     m_nPointCount++;
  9.   }
  10.   ~Point()
  11.   {
  12.     m_nPointCount--;
  13.   }
  14.   static void output()
  15.   {
  16.     printf("%d\n", m_nPointCount);
  17.   }
  19. private:
  20.   static int m_nPointCount;
  21. };
  24. int main()
  25. {
  26.   Point pt;
  27.   pt.output();
  28.   return 0;
  29. }

按Ctrl+F7编译无错误，按 F7 生成 EXE 程序时报链接错误。

  1. error LNK2001: unresolved external symbol "private: static int Point::m_nPointCount" (?m_nPointCount@Point@@0HA)

这是因为类的静态成员变量在使用前必须先初始化。
在main()函数前加上 int Point::m_nPointCount = 0; 再编译链接无错误，运行程序将输出 1。
结论 5：类的静态成员变量必须先初始化再使用

思考总结：静态资源属于类，但是是独立于类存在的。从 J 类的加载机制的角度讲，静态资源是类初始化的时候加载的，而非静态资源是类实例化对象的时候加载的。 类的初始化早于类实例化对象，比如Class.forName(“xxx”)方法，就是初始化了一个类，但是并没有实例化对象，只是加载这个类的静态资源罢 了。所以对于静态资源来说，它是不可能知道一个类中有哪些非静态资源的；但是对于非静态资源来说就不一样了，由于它是实例化对象出来之后产生的，因此属于类的这些东西它都能认识。所以上面的几个问题答案就很明确了：

  • 静态方法能不能引用非静态资源？不能，实例化对象的时候才会产生的东西，对于初始化后就存在的静态资源来说，根本不认识它。
  • 静态方法里面能不能引用静态资源？可以，因为都是类初始化的时候加载的，大家相互都认识。
  • 非静态方法里面能不能引用静态资源？可以，非静态方法就是实例方法，那是实例化对象之后才产生的，那么属于类的内容它都认识。

static 修饰类：这个用得相对比前面的用法少多了，static 一般情况下来说是不可以修饰类的， 如果 static 要修饰一个类，说明这个类是一个静态内部类（注意 static 只能修饰一个内部类），也就是匿名内部类。像线程池 ThreadPoolExecutor 中的四种拒绝机制 CallerRunsPolicy、AbortPolicy、DiscardPolicy、 DiscardOldestPolicy 就是静态内部类。静态内部类相关内容会在写内部类的时候专门讲到。

总结

  • 静态成员函数中不能调用非静态成员。
  • 非静态成员函数中可以调用静态成员。因为静态成员属于类本身，在类的对象产生之前就已经存在了，所以在非静态成员函数中是可以调用静态成员的。
  • 静态成员变量使用前必须先初始化，如int MyClass::m_nNumber = 0;)，否则会在 linker 时出错。

一般总结 在类中，static 可以用来修饰静态数据成员和静态成员方法

静态数据成员

  • 静态数据成员可以实现多个对象之间的数据共享，它是类的所有对象的共享成员，它在内存中只占一份空间，如果改变它的值，则各对象中这个数据成员的值都被改变。
  • 静态数据成员是在程序开始运行时被分配空间，到程序结束之后才释放，只要类中指定了静态数据成员，即使不定义对象，也会为静态数据成员分配空间。
  • 静态数据成员可以被初始化，但是只能在类体外进行初始化，若未对静态数据成员赋初值，则编译器会自动为其初始化为 0。
  • 静态数据成员既可以通过对象名引用，也可以通过类名引用

静态成员函数

  • 静态成员函数和静态数据成员一样，他们都属于类的静态成员，而不是对象成员。
  • 非静态成员函数有 this 指针，而静态成员函数没有 this 指针。
  • 静态成员函数主要用来方位静态数据成员而不能访问非静态成员。

再给一个利用类的静态成员变量和函数的例子以加深理解，这个例子建立一个学生类，每个学生类的对象将组成一个双向链表，用一个静态成员变量记录这个双向链表的表头，一个静态成员函数输出这个双向链表。

  1. #include <stdio.h>
  2. #include <string.h>
  3. const int MAX_NAME_SIZE = 30;  
  5. class Student  
  6. {  
  7. public:  
  8.     Student(char *pszName);
  9.     ~Student();
  10. public:
  11.     static void PrintfAllStudents();
  12. private:  
  13.     char    m_name[MAX_NAME_SIZE];  
  14.     Student *next;
  15.     Student *prev;
  16.     static Student *m_head;
  17. };  
  19. Student::Student(char *pszName)
  20. {  
  21.     strcpy(this->m_name, pszName);
  23.     //建立双向链表，新数据从链表头部插入。
  24.     this->next = m_head;
  25.     this->prev = NULL;
  26.     if (m_head != NULL)
  27.         m_head->prev = this;
  28.     m_head = this;  
  29. }  
  31. Student::~Student ()//析构过程就是节点的脱离过程  
  32. {  
  33.     if (this == m_head) //该节点就是头节点。
  34.     {
  35.         m_head = this->next;
  36.     }
  37.     else
  38.     {
  39.         this->prev->next = this->next;
  40.         this->next->prev = this->prev;
  41.     }
  42. }  
  44. void Student::PrintfAllStudents()
  45. {
  46.     for (Student *p = m_head; p != NULL; p = p->next)
  47.         printf("%s\n", p->m_name);
  48. }
  50. Student* Student::m_head = NULL;  
  52. void main()  
  53. {   
  54.     Student studentA("AAA");
  55.     Student studentB("BBB");
  56.     Student studentC("CCC");
  57.     Student studentD("DDD");
  58.     Student student("MoreWindows");
  59.     Student::PrintfAllStudents();
  60. }

程序将输出：
C语言 存储类 - 图4