C++力量與靈活性的完美結合
類型限定符是實現類型安全和性能優化的重要工具。它們為程序員提供了強大的類型檢查和內存管理能力，同時保持了代碼的靈活性。
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 定義了最大值常量。
