类型限定符是实现类型安全和性能优化的重要工具。它们为程序员提供了强大的类型检查和内存管理能力，同时保持了代码的灵活性。
1.const限定符
const 限定符用于声明一个变量，告诉编译器该变量在程序运行期间不可被更改。这意味着一旦你初始化了一个 const 变量，你就不能再去修改它。这是保证数据完整性的一个重要手段。
#include <iostream>
int main()
{
const int x = 10;
// x = 20; // Error: Assignment of read-only variable 'x'
std::cout << "x: " << x << std::endl;
return 0;
}在上面的代码中，变量x被声明为const int类型，因此任何尝试修改x的操作都会导致编译错误。const关键字不仅可以用于基本数据类型，还可以用于指针和成员函数，以确保它们不会修改其所指向的数据或对象。
const 还可以与指针结合使用，用于限定指针本身、指针指向的数据或两者都不能被修改。下面是一些示例：
int a = 10;
int b = 20;
// 常量指针，指针本身的值不能修改
const int* ptr1 = &a;
// ptr1 = &b; // 错误，不能修改指针本身的值
// 指针指向常量，指针指向的数据不能修改
int* const ptr2 = &a;
// *ptr2 = 30; // 错误，不能修改指针指向的数据
// 指针本身和指向的数据都是常量
const int* const ptr3 = &a;
// ptr3 = &b; // 错误，不能修改指针本身的值
// *ptr3 = 30; // 错误，不能修改指针指向的数据2.volatile：易变限定符
volatile关键字用于告诉编译器，某个变量的值可能会在程序的控制之外被修改，因此编译器不应该对该变量进行优化。这在多线程编程和嵌入式系统中特别有用。让我们看一个简单的示例：
#include <iostream>
int main() {
volatile int x = 10;
while (x == 10) {
std::cout << "x is still 10" << std::endl;
}
return 0;
}在上面的示例中，变量x被声明为volatile int类型，这意味着即使在循环中没有对x进行修改，编译器也不会对循环进行优化，以避免出现意外行为。
3.mutable：可变限定符
mutable关键字允许在const成员函数中修改被声明为mutable的数据成员。这对于某些特定的设计模式和优化来说非常有用。让我们看一个示例：
#include <iostream>
class Example {
private:
mutable int x;
public:
Example(int val) : x(val) {}
void modify() const {
x = 20; // OK: modifying mutable member in const member function
}
void print() const {
std::cout << "x: " << x << std::endl;
}
};
int main() {
Example obj(10);
obj.print();
obj.modify();
obj.print();
return 0;
}在上面的示例中，虽然modify()函数被声明为const，但由于x被声明为mutable int类型，因此仍然可以在const成员函数中修改它的值。
4.constexpr：常量表达式限定符
constexpr关键字用于声明一个常量表达式，这意味着该表达式在编译时就可以计算出其值。constexpr可以应用于变量、函数以及构造函数。让我们看一个示例：
#include <iostream>
constexpr int square(int x) {
return x * x;
}
int main() {
constexpr int result = square(5); // OK: square(5) can be evaluated at compile time
std::cout << "Result: " << result << std::endl;
return 0;
}在上面的示例中，函数square()被声明为constexpr，因此可以在编译时计算出其返回值，从而使得result也成为了一个编译时常量。
5.signed 和 unsigned 限定符
signed 和 unsigned 限定符用于指定整型变量的符号性质。signed 表示变量为有符号整数，unsigned 表示变量为无符号整数。这两个限定符在定义变量时必须明确使用，以确保变量类型的正确性。
signed int signedNum = -1; // 声明一个有符号整数
unsigned int unsignedNum = 1; // 声明一个无符号整数6.enum限定符
enum 关键字用于定义一个枚举类型，它允许你使用整数来表示一组命名的常量。使用 enum 可以提高代码的可读性和维护性。
enum Color {
RED,
GREEN,
BLUE
};
int main() {
Color c = RED; // 声明一个 Color 类型的变量并初始化为 RED
// c = 4; // 错误：枚举类型是有符号整数类型
return 0;
}7.static 类型限定符
static 类型限定符在 C++ 中有多种用途。它可以用于声明静态变量、静态成员变量和静态函数。
(1) 静态局部变量
在函数内部使用 static 限定符声明的局部变量，其生命周期将延长到程序结束。下面是一个示例：
void func() {
static int counter = 0;
counter++;
std::cout << "Counter: " << counter << std::endl;
}
int main() {
for (int i = 0; i < 5; ++i) {
func();
}
return 0;
}在这个例子中，func 函数中的 counter 变量被声明为 static。每次调用 func 时，counter 的值都会被保留，而不是重新初始化。
(2) 静态成员变量和静态成员函数
#include <iostream>
class Counter {
public:
// 静态成员变量，用于存储所有Counter实例共享的计数
static int count;
// 静态成员函数，用于增加计数
static void increment() {
count++;
}
// 静态成员函数，用于打印当前计数
static void printCount() {
std::cout << "Count: " << count << std::endl;
}
// 构造函数
Counter() {
// 每次创建新的Counter实例时，增加计数
increment();
}
// 析构函数
\~Counter() {
// 每次销毁Counter实例时，减少计数（可选，取决于需求）
decrement();
}
private:
// 静态成员函数，用于减少计数
static void decrement() {
count--;
}
};
// 在类的外部初始化静态成员变量
int Counter::count = 0;
int main() {
Counter c1; // 创建第一个Counter实例
Counter c2; // 创建第二个Counter实例
Counter::printCount(); // 输出: Count: 2
c1.increment(); // c1增加计数
c2.increment(); // c2增加计数
Counter::printCount(); // 输出: Count: 4
return 0;
}在这个例子中，我们定义了一个名为 Counter 的类，它有一个静态成员变量 count 和两个静态成员函数 increment 和 printCount。静态成员变量 count 被初始化为0，并存储了所有 Counter 实例共享的计数值。静态成员函数 increment 用于增加 count 的值，而 printCount 用于打印当前的计数值。
在 main 函数中，我们创建了两个 Counter 实例 c1 和 c2。每次创建新的 Counter 实例时，都会调用静态成员函数 increment 来增加计数，所以 count 的值会随着新实例的创建而增加。通过调用 Counter::printCount() 而不是 c1.printCount() 或 c2.printCount()，我们直接访问了静态成员函数，这表明静态成员函数与类关联，而不是与类的任何特定实例关联。
静态成员变量和函数是类设计中的一个强大工具，它们允许类在所有实例之间共享数据，而不需要为每个实例单独维护这些数据。这对于实现一些通用功能，如计数器、单例模式或全局配置等非常有用。
8.引用限定符&和&&
引用限定符&和&&用于修饰成员函数，指定其是否可以用于左值或右值对象。&表示函数可以用于左值对象，而&&表示函数可以用于右值对象。这对于实现移动语义和完美转发非常有用。让我们看一个示例：
#include <iostream>
class Example {
public:
void modifyLvalue(int& x) {
std::cout << "Modifying lvalue: " << ++x << std::endl;
}
void modifyRvalue(int&& x) {
std::cout << "Modifying rvalue: " << ++x << std::endl;
}
};
int main() {
Example obj;
int a = 10;
obj.modifyLvalue(a); // OK: lvalue argument
obj.modifyRvalue(20); // OK: rvalue argument
return 0;
}在上面的示例中，成员函数modifyLvalue()接受一个左值引用参数，而modifyRvalue()接受一个右值引用参数，从而使得我们可以根据对象的类型选择合适的成员函数进行调用。
9.类型限定符的综合应用
让我们通过一个综合示例来展示这些类型限定符是如何一起工作的：
#include <iostream>
#include <thread>
const int MAX_VALUE = 100; // 定义一个常量整数
volatile bool stopFlag = false; // 定义一个 volatile 布尔变量
signed int score = 0; // 定义一个有符号整数分数
enum GameState {
RUNNING,
PAUSED,
FINISHED
};
GameState state = RUNNING; // 初始化游戏状态为 RUNNING
void printScore(int s) {
std::cout << "Score: " << s << std::endl;
}
void updateScore(int& s, int add) {
s += add;
}
void gameLoop() {
while (!stopFlag) {
if (state == PAUSED) {
std::this_thread::sleep_for(std::chrono::milliseconds(100));
continue;
}
updateScore(score, 1);
printScore(score);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
int main() {
std::thread t(gameLoop);
std::cout << "Game is running..." << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(5));
stopFlag = true; // 设置停止标志位
t.join();
std::cout << "Game Over. Final Score
std::cout << "Game Over. Final Score: " << score << std::endl;
return 0;
}在这个示例中，我们创建了一个简单的游戏循环，它通过一个 volatile 布尔变量来控制何时停止循环，并通过一个 signed 整数变量来跟踪得分。使用 enum 定义了游戏状态，并通过 const 定义了最大值常量。
