c++复习-基础-从c到c++-类型限定符+存储类限定符+引用

参考：
https://www.runoob.com/cplusplus/cpp-tutorial.html
和gpt生成的内容

---

类型限定符

• const

  const int NUM = 10; // 定义常量NUM，值不能修改
  const int* ptr = # // 定义常量指针，指针所指的值不可修改
  int const* ptr2 = # // 与上一行等价
  

• volatile

  • 表示可能被程序以外的因素改变，如硬件或线程

  volatile int num = 20;
  

• restrict

  • C99中增加的，由restrict修饰的指针是唯一一种访问的方式
  • 它告诉编译器，在给定的代码块中，被标记为 restrict 的指针是唯一访问其所指向内存的指针，其他指针不能访问。因此编译器可以更自由地进行一些针对性的优化，如寄存器分配和指令重排
  • 并非所有编译器都支持，所以使用时需要考虑兼容性

  void foo(int* restrict a, int* restrict b, int n) {
      for (int i = 0; i < n; ++i) {
          a[i] += b[i];
      }
  }
  

• mutable

  • 表示类中的成员变量可以在const成员函数中被修改
  • 成员函数带const表示不会修改对象中的数据成员，但是可以修改类的mutable数据成员

  class Example {
  public:
  		// mutable 关键字允许在 const 成员函数中修改成员变量
      void set_value(int value) const {
          value_ = value; 
      }
  private:
      mutable int value_;
  };
  

• static

  • 静态变量的作用域仅限于当前文件或当前函数内。
  • 静态局部变量，只会初始化一次；而普通局部变量，每次函数调用都会重新初始化

  #include <iostream>
  
  void exampleFunction() {
      // 静态局部变量，只会初始化一次
      static int staticVariable = 0;
  
      // 普通局部变量，每次函数调用都会重新初始化
      int localVariable = 0;
  
      // 修改静态变量和普通变量
      staticVariable++;
      localVariable++;
  
      // 输出结果
      std::cout << "Static Variable: " << staticVariable << std::endl;
      std::cout << "Local Variable: " << localVariable << std::endl;
  }
  
  int main() {
      // 多次调用函数，观察静态变量和局部变量的变化
      exampleFunction();
      exampleFunction();
      exampleFunction();
  
      return 0;
  }
  /* 输出：
  Static Variable: 1
  Local Variable: 1
  Static Variable: 2
  Local Variable: 1
  Static Variable: 3
  Local Variable: 1
  */
  

• register

  • register是建议编译器将变量存储在寄存器中，以提高程序执行速度，但是是否如此是由编译器决定的。

存储类限定符

• auto

  • C++17开始，auto关键字不再是存储类说明符了
  • 用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。

• register

  • C++17开始，register关键字被弃用
  • 不能用&，因为没有内存位置

• static

• extern

  • 提供一个全局变量的引用，即这个变量对所有的程序文件都是可见的。

  假设有两个文件

  // main.cpp
  #include <iostream>
   
  int count ;
  extern void write_extern();
   
  int main()
  {
     count = 5;
     write_extern(); // 输出5
  }
  
  // support.cpp
  #include <iostream>
   
  extern int count;
   
  void write_extern(void)
  {
     std::cout << "Count is " << count << std::endl;
  }
  

• mutable

• thread_local

  • c++11
  • 用于声明线程局部存储的变量。线程局部存储意味着每个线程都有其自己独立的变量实例，不同线程之间的变量互不影响
  • thread_local 说明符可以与 static 或 extern 合并。
  • 可以将 thread_local 仅应用于数据声明和定义，thread_local 不能用于函数声明或定义

  编译命令是：g++ -std=c++11 hello.cpp -o hello -pthread

  (base) [p@localhost ~]$ g++ -std=c++11  hello.cpp -o hello 
  (base) [p@localhost ~]$ ./hello
  terminate called after throwing an instance of 'std::system_error'
    what():  Enable multithreading to use std::thread: Operation not permitted
  已放弃(吐核)
  (base) [p@localhost ~]$ g++ -std=c++11  hello.cpp -o hello -pthread
  

  #include <iostream>
  #include <thread>
  
  thread_local int threadLocalVariable = 0;
  
  void exampleFunction() {
      // 修改线程局部变量
      threadLocalVariable++;
      // 输出结果
      std::cout << "Thread ID: " << std::this_thread::get_id() << ", Thread Local Variable: " << threadLocalVariable << std::endl;
  }
  
  int main() {
      // 创建两个线程并调用函数
      std::thread thread1(exampleFunction);
      std::thread thread2(exampleFunction);
  
      // 等待线程执行完毕
      thread1.join();
      thread2.join();
  
      return 0;
  }
  

基本输入输出

对象	说明
cin	标准输入流
cout	标准输出流
cerr	cerr << 标准错误流。cerr对象是非缓冲的，会立即输出
clog	clog << 标准日志流。clog对象是缓冲的，只有缓冲区满或者刷新时才输出

引用

引用变量是一个别名，即一个已经存在的变量的另一个名字。

引用与指针的区别：

• 不存在空引用，引用必须连接到一块合法的内存
• 一旦引用被初始化为一个对象，就不能再指向另一个对象，但是指针可以在任何时候指向另一个对象
• 引用必须在创建的时候初始化，但指针可以在任何时间初始化

int& r = i; // r是一个被初始化为i的整型引用

引用作为参数传递给函数没什么好说的，但是函数返回引用需要注意：要么返回的引用，其指向的变量是本文件的全局变量，要么返回的是静态变量的引用。(被引用的对象不能超出作用域)