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

• auto
• register
• static
• extern
• mutable
• thread_local (C++11)
  : C/ k2 ?! k1 @# k) \

: ~: Z5 V' {1 L, w2 M4 \. b从 C++ 17 开始，auto 关键字不再是 C++ 存储类说明符，且 register 关键字被弃用。
; z  m5 P7 T; X& f( y; ^( r

auto 存储类
; h7 J* }4 `( `" l5 r; v

自 C++ 11 以来，auto 关键字用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。


C++98标准中auto关键字用于自动变量的声明，但由于使用极少且多余，在C++11中已删除这一用法。
2 M  W5 s5 `8 Y3 b
% r7 E! _$ ]' G. A, e
, ]3 k% I  y( ?根据初始化表达式自动推断被声明的变量的类型，如：
2 m4 z1 C# [) ^) Q

1. 
   
2. auto f=3.14;      //double
   ' e1 E2 b$ q) F  J" q, J; T' D
3. auto s("hello");  //const char*
   ! W0 s1 [! o5 R  q  e; d/ J% ]
4. auto z = new auto(9); // int*
   
5. auto x1 = 5, x2 = 5.0, x3='r';//错误，必须是初始化为同一类型

复制代码

/ t, _: H1 S8 |$ @0 A
6 O7 j  O4 X& _+ Uregister 存储类register
1 ~3 G, w; H# V3 E' ?% v. D

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

1. 
   % {8 d; r. L7 [8 s/ K) h
2. {   register int  miles;}

复制代码

$ f- N# |( k' c# z9 P
# s' K" J3 A' l! [  |寄存器只用于需要快速访问的变量，比如计数器。应注意的是，定义 'register' 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

9 o4 r( |+ ]: S
static 存储类
2 _. j2 Z+ ?  ~+ s
static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

$ \0 ?8 f4 I7 z
static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

( l) ^& s4 }- K; D, ]3 I
在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。
+ R9 {; N$ F( t  p# L, P* e实例

1. 
   
2. #include <iostream> // 函数声明
   
3. void func(void);
   ) E' j' c% f# a$ S4 W- n4 h+ \
4. static int count = 10; /* 全局变量 */
   
5. int main()
   ' g! {6 W* F+ `# L* g" R! V& O0 j
6. {     
   $ B5 K$ w( R6 ~; x3 u, Q
7.     while(count--)     
   
8.     {         
   
9.        func();         
   
10.      }   
    
11.      return 0;
    7 K1 p3 b  Q  Q9 W
12. }// 函数定义void
    + C  c( j( \  X( D5 p" B
13. func( void )
    $ a! I: J( S! r) @" H; F
14. {   
    
15.      static int i = 5; // 局部静态变量   
    
16.      i++;        
    
17.      std::cout << "变量 i 为 " << i ;      
    . k' O: V8 x' s* X' r) {
18.      std::cout << " , 变量 count 为 " << count << std::endl;
    
19. }

复制代码

, X6 O. }" n; \当上面的代码被编译和执行时，它会产生下列结果：
变量 i 为6,变量 count 为9
变量 i 为7,变量 count 为8
变量 i 为8,变量 count 为7
! [" q" ^% N" ]; o变量 i 为9,变量 count 为6
变量 i 为10,变量 count 为5
变量 i 为11,变量 count 为4
变量 i 为12,变量 count 为3
- N# D- r3 q( M6 c  j; |变量 i 为13,变量 count 为2
变量 i 为14,变量 count 为1
变量 i 为15,变量 count 为0

* r4 L4 R+ L1 Q) |4 M% e+ G9 P  h
- I$ C& R* c  k' p: Cextern 存储类

extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 'extern' 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。


  Y. q9 t/ U( z, N: w7 h* {当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。


9 K! M$ p3 [, Y: X( b# V: J" [. qextern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示：
7 V/ u$ ?4 c8 z/ y% O7 @0 D+ z第一个文件：main.cpp实例

1. <font face="Tahoma"><font size="3">
   * W$ [) }6 `* T, |2 T
2. #include <iostream>int count ;extern void write_extern(); int main(){  count = 5;    write_extern();}</font></font>
   6 n# @; t( Q: V, ~* c% d

复制代码

+ C+ f; }- v1 e9 H% Y第二个文件：support.cpp实例

1. 
   
2. #include <iostream>
   
3. extern int count;
   
4. void write_extern(void)
   ( T1 N8 w& q8 z# ^9 R4 g
5. {   
   6 P! W" ^3 Y7 L/ }) z) B
6.    std::cout << "Count is " << count << std::endl;
   
7. }

复制代码

在这里，第二个文件中的 extern 关键字用于声明已经在第一个文件 main.cpp 中定义的 count。现在 ，编译这两个文件，如下所示：
0 J+ r, C  C- m$ g++ main.cpp support.cpp -o write
- \, e' M3 c, s# Z4 m, {

1 ]; R9 w3 R, a4 Y; T这会产生 write 可执行程序，尝试执行 write，它会产生下列结果：
- q' i! l! p8 ~: @; m4 b$ ./write

    Countis5

( t0 l8 U/ }- J! B
mutable 存储类

mutable 说明符仅适用于类的对象，这将在本教程的最后进行讲解。它允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改。

- v8 E% e' p* f/ k8 f! |' J1 U4 N
" A* r: U4 ]5 R4 g/ Rthread_local 存储类
( e# [+ ^. j) s
0 F) b9 p/ c! y; Z" N. w
; {' f+ P8 M' D" i使用 thread_local 说明符声明的变量仅可在它在其上创建的线程上访问。变量在创建线程时创建，并在销毁线程时销毁。每个线程都有其自己的变量副本。
, u/ e! z! l6 G2 X* O
  `3 k' o. \: x. i1 W# T/ H
thread_local 说明符可以与 static 或 extern 合并。


可以将 thread_local 仅应用于数据声明和定义，thread_local 不能用于函数声明或定义。

6 V, w8 ?1 _  q% b$ A) i
以下演示了可以被声明为 thread_local 的变量：

1. 
   
2. thread_local int x;  // 命名空间下的全局变量
   
3. class X{static thread_local std::string s; // 类的static成员变量};
   0 X+ J. r( k4 S8 V
4. static thread_local std::string X::s;  // X::s 是需要定义的
     ~7 N' W) l5 W9 A+ z
5. void foo()
   : Q8 D) ~5 B* s8 C, u
6. {   
   
7.   thread_local std::vector<int> v;  // 本地变量
   0 U7 \3 T0 B, }4 O) m- _; C
8. }     

复制代码

4 c$ {  M2 B" o% d; Y# J$ |
+ a& N5 n0 {  Q
, A$ \% u+ e8 [2 H/ O

谢谢分享