C++ 存储类,C++11的thread_local 存储类

admin

C++ 存储类

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

• auto
• register
• static
• extern
• mutable
• thread_local (C++11)
  

从 C++ 17 开始，auto 关键字不再是 C++ 存储类说明符，且 register 关键字被弃用。

auto 存储类

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

C++98标准中auto关键字用于自动变量的声明，但由于使用极少且多余，在 C++17 中已删除这一用法。

根据初始化表达式自动推断被声明的变量的类型，如：

1. auto f=3.14;      //double
   
2. auto s("hello");  //const char*
   
3. auto z = new auto(9); // int*
   
4. auto x1 = 5, x2 = 5.0, x3='r';//错误，必须是初始化为同一类型

复制代码

register 存储类

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

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

复制代码

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

static 存储类

static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

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

在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。

1. #include <iostream>
   
2. 
   
3. // 函数声明
   
4. void func(void);
   
5. 
   
6. static int count = 10; /* 全局变量 */
   
7. 
   
8. int main()
   
9. {
   
10.     while(count--)
    
11.     {
    
12.        func();
    
13.     }
    
14.     return 0;
    
15. }
    
16. // 函数定义
    
17. void func( void )
    
18. {
    
19.     static int i = 5; // 局部静态变量
    
20.     i++;
    
21.     std::cout << "变量 i 为 " << i ;
    
22.     std::cout << " , 变量 count 为 " << count << std::endl;
    
23. }

复制代码

当上面的代码被编译和执行时，它会产生下列结果：

1. 变量 i 为 6 , 变量 count 为 9
   
2. 变量 i 为 7 , 变量 count 为 8
   
3. 变量 i 为 8 , 变量 count 为 7
   
4. 变量 i 为 9 , 变量 count 为 6
   
5. 变量 i 为 10 , 变量 count 为 5
   
6. 变量 i 为 11 , 变量 count 为 4
   
7. 变量 i 为 12 , 变量 count 为 3
   
8. 变量 i 为 13 , 变量 count 为 2
   
9. 变量 i 为 14 , 变量 count 为 1
   
10. 变量 i 为 15 , 变量 count 为 0

复制代码

extern 存储类

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

当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。

extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示：

第一个文件：main.cpp

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

复制代码

第二个文件：support.cpp

1. #include <iostream>
   
2. 
   
3. extern int count;
   
4. 
   
5. void write_extern(void)
   
6. {
   
7.    std::cout << "Count is " << count << std::endl;
   
8. }

复制代码

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

$ g++ main.cpp support.cpp -o write

这会产生 write 可执行程序，尝试执行 write，它会产生下列结果：

$ ./writeCount is 5
mutable 存储类

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

thread_local 存储类

使用 thread_local 说明符声明的变量仅可在它在其上创建的线程上访问。 变量在创建线程时创建，并在销毁线程时销毁。 每个线程都有其自己的变量副本。

thread_local 说明符可以与 static 或 extern 合并。

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

以下演示了可以被声明为 thread_local 的变量：

1. thread_local int x;  // 命名空间下的全局变量
   
2. class X
   
3. {
   
4.     static thread_local std::string s; // 类的static成员变量
   
5. };
   
6. static thread_local std::string X::s;  // X::s 是需要定义的
   
7. 
   
8. void foo()
   
9. {
   
10.     thread_local std::vector<int> v;  // 本地变量
    
11. }

复制代码

std::cout << "Count is " << count << std::endl;

在前面的学习中我们看到的输出没有 std::，而这一节出现了上面的代码。

std 是标准库函数使用的命名空间，是 standard（标准）的缩写。

using namespace std ，它声明了命名空间 std，后续如果有未指定命名空间的符号，那么默认使用 std，这样就可以使用 cin、cout、vector 等。

假设你不使用预处理 using namespace std;,就要加上 std::cin 或者 std::cout。

cin 用于从控制台获取用户输入，cout 用于将数据输出到控制台。

cin 是输入流对象，cout 是输出流对象，它们分别可以用 >> 和 <<，是因为分别在其类中对相应运算符进行了重载。

static 修饰类的成员变量

• 1). 静态成员变量是先于类的对象而存在
• 2). 这个类的所有对象共用一个静态成员
• 3). 如果静态成员是公有的，那么可以直接通过类名调用
• 4). 静态成员数据在声明时候类外初始化
• 1. #include <iostream>
     
  2. 
     
  3. using namespace std;
     
  4. class Data
     
  5. {
     
  6. public:
     
  7.     Data(){}
     
  8.     ~Data(){}
     
  9.     void show()
     
  10.     {
      
  11.         cout<<this->data<<" "<<number<<endl;
      
  12.     }
      
  13. 
      
  14.     static void showData()//先于类的对象而存在
      
  15.     {
      
  16.         //这方法调用的时候不包含this指针
      
  17.         cout<<" "<<number<<endl;
      
  18.     }
      
  19. 
      
  20. private:
      
  21.     int data;
      
  22. public:
      
  23.     static int number; //静态数据在声明时候类外初始化
      
  24. };
      
  25. int Data::number=0;//静态成员初始化
      
  26. 
      
  27. int main()
      
  28. {
      
  29.     Data::showData();//通过类名直接调用
      
  30. 
      
  31. 
      
  32.     Data::number = 100;//通过类名直接使用
      
  33.     Data d;
      
  34.     d.show();
      
  35.     d.showData();//通过对象调用
      
  36. 
      
  37.     cout << "Hello World!" << endl;
      
  38.     return 0;
      
  39. }

  复制代码
  2.static 修饰类的成员方法
  
  
  • 1). 静态成员函数是先于类的对象而存在
  • 2). 可用类名直接调用（公有）
  • 3). 在静态成员函数中没有this指针，所以不能使用非静态成员
    
  const 修饰--常量 ---- const修饰的常量代替宏定义
  修饰成员变量
  const int data;
  const 修饰的成员变量必须在构造方法的参数列表初始化（const static int pdata=10;除外）const 修饰的成员变量不能被修改
  修饰成员方法
  void showData()const{ }
  const 修饰的成员函数中不能修改成员变量，不能调用非 const 修饰的函数