参考链接

​​RUNOOB.COM​​

数据存储类说明

      在编程过程需要限制和扩大函数以及变量的作用域（关于作用域上一篇已经提到点），需要一些特定的类来进行修饰。为实现上面的功能，C++定义了存储类。C++程序中使用的存储类：auto，register，static，extern，mutable，thread_local。

       但是随着C++版本的更新，从C++17开始，auto关键字不再是C++存储类，并且register关键字被弃用。

auto关键字

       auto关键字主要有两种情况：声明变量时会根据初始化的表达式自行初始化类型，声明函数时返回值的占位符。

#include <iostream>
using namespace std;
int main()
{
  auto dataType = 5.66;           //double类型
  auto dataStr("天眼工作室");      //char*
  auto dataPoint = new auto(20);  //返回常量所在的地址
  cout << "dataType = " << dataType << endl;
  cout << "dataStr = " << dataStr << endl;
  cout << "dataPoint = " << *dataPoint << endl; //返回指针地址对应的数值
  getchar();
  return 0;
}

运行结果

dataType = 5.66
dataStr = 天眼工作室
dataPoint = 20

说明：但是auto关键字也不是万能的，在对多个表达式一起进行自行初始化的时候，需要对应的类型一致。

auto dataType1 = 5.55, dataType2 = 8.88, dataType3 = 6.66;         //正确
auto dataType1 = 5.55, dataType2 = 8.88, dataType3 = "天眼工作室";  //错误，因为赋值类型不一致

register关键字

     register翻译为中文是缓存器，其实就是将要修饰的变量放到寄存器，这样做目的为了做一些快速计数。因为我们在做C++处理时，主要是将数据存储在RAM。因为将数据存储在寄存器中，所以变量的最大值不能超过寄存器（一般情况下是一个变量），并且不能使用‘&’运算符（在内存中使用‘&’）。

register int dataCount;

static关键字

      static在程序的运行的整个过程保持局部变量的存在。这个必须说一下static的生命力很完成，对于一般的局部变量会面临空间的声明和摧毁，当然static也适用全局变量。我们还是来一段代码来更好的说明一下：

#include <iostream>
using namespace std;
//函数声明
void CountFun();
void staticCountFun();

int main()
{
  int iCout = 5;
  cout << "静态变量测试函数" << endl;
  while (iCout)
  {
    iCout = iCout - 1;
    staticCountFun();
  }
  cout << "普通变量测试函数" << endl;
  iCout = 5;
  while (iCout)
  {
    iCout = iCout - 1;
    CountFun();
  }
  getchar();
  return 0;
}
/********静态变量测试函数**********/
void staticCountFun()
{
  static int stICount = 5;
  cout << stICount-- << endl;

}
/********普通变量测试函数*********/
void CountFun()
{
  int iTmpCount = 5; 
  cout << iTmpCount-- << endl;
}

运行结果

静态变量测试函数
5
4
3
2
1
普通变量测试函数
5
5
5
5
5

     通过上面程序的运行结果，我们明显可以看到，子函数在来回调用过程中，static修饰的变量不会销毁申请的内存空间。

extern关键字

     当在写大工程文件，肯定不会只通过单个文件实现。如果可以实现估计这个代码也没有想看，自己以后也会再看。那么解决这个问题就需要进行多个文件编写，每个文件实现不同小功能。鉴于上面需求，C++创建了extern关键字。该关键字可以实现多个文件之间的函数和变量调用。不过，一定要注意extern对变量（数组、字符串等）和函数有不同的使用方式。

主文件main.cpp

#include "function.h"

int main()
{
  int iCout = 5;
  cout << "静态变量测试函数" << endl;
  while (iCout)
  {
    iCout = iCout - 1;
    staticCountFun();
  }
  cout << "普通变量测试函数" << endl;
  iCout = 5;
  while (iCout)
  {
    iCout = iCout - 1;
    CountFun();
  }
  getchar();
  return 0;
}

子文件function.cpp

#include "function.h"

/********静态变量测试函数**********/
void staticCountFun()
{
  static int stICount = 5;
  cout << stICount-- << endl;

}
/********普通变量测试函数*********/
void CountFun()
{
  int iTmpCount = 5;
  cout << iTmpCount-- << endl;
}

子文件function.h

#include <iostream>
using namespace std;
//函数声明
extern void CountFun();
extern void staticCountFun();

运行结果

静态变量测试函数
5
4
3
2
1
普通变量测试函数
5
5
5
5
5

mutable关键字

     mutable其实在这里讲对于初学者可能有点难，因为mutable主要允许对象成员的变量可以进行改变。说白了就是和const相反操作，对const函数里面的变量修改。下面我们看一下代码：

#include <iostream>
using namespace std;

class Project {
public:
  Project();
  ~Project();
  int getProjectName() const;
  int getProjectTimes() const;

private:
  mutable int iTimes;
  int iName;
};
Project::Project()
{
  iTimes = 0;
}
Project::~Project() {}
int Project::getProjectName() const
{
  cout << "天眼工作室" << endl;
  iTimes++;
  return 1;
}
int Project::getProjectTimes() const
{
  return iTimes;
}
int main()
{
  Project *project = new Project();
  for (int i = 0; i < 5; i++) 
  {
    project->getProjectName();
  }
  cout << "调用" << project->getProjectTimes() << "次" << endl;
  delete project;

  getchar();
  return 0;
}

运行结果

天眼工作室
天眼工作室
天眼工作室
天眼工作室
天眼工作室
调用5次

thread_local关键字

     thread_local仅在创建的线程上进行访问，并且在销毁线程时销毁。它主要是解决多线程之间数据不能共享。

#include <iostream>
#include <thread>

using namespace std;

class threadLocalTest {
public:
  threadLocalTest()
  {
    cout << this_thread::get_id()
      << " " << __FUNCTION__
      << "(" << (void *)this << ")"
      << endl;
  }

  ~threadLocalTest()
  {
    cout << this_thread::get_id()
      << " " << __FUNCTION__
      << "(" << (void *)this << ")"
      << endl;
  }

  // 线程中，第一次使用前初始化
  void doStart()
  {
  }
};

thread_local threadLocalTest tmpTest;

int main() {
  tmpTest.doStart();
  thread threadName([]() {
    cout << "Thread: "
      << this_thread::get_id()
      << " entered" << endl;
    tmpTest.doStart();
  });

  threadName.join();
  getchar();
  return 0;
}

更多《计算机视觉与图形学》知识，可关注下方公众号：

刷野打怪上王者·C++篇·第7期·数据存储_静态变量