#include <string>
#include <vector>
#include <cassert>

// 1. 基本類型的常量
const int MAX_USERS = 1000;        // 一個整型常量
const double PI = 3.14159;       // 一個雙精度浮點常量
const bool IS_ENABLED = true;    // 一個布爾常量

// 2. 常量引用 (Reference to Const)
const std::string GREETING = "Hello, World!";
const std::string& ref_greeting = GREETING; // 引用一個常量字符串，不能通過 ref_greeting 修改 GREETING

void printMessage(const std::string& msg){ // 函數(shù)參數(shù)為常量引用，保證函數(shù)內(nèi)部不修改傳入的字符串
    // msg = "Cannot change"; // 編譯錯誤：不能修改 const 引用指向的內(nèi)容
    std::cout << msg << std::endl;
}

// 3. 指向常量的指針 (Pointer to Const)
const int* ptr_to_const_int; // ptr_to_const_int 是一個指針，它指向一個常量 int
int value = 10;
ptr_to_const_int = &value;   // 指針可以指向一個非 const 變量...
// *ptr_to_const_int = 20;   // 編譯錯誤：不能通過 ptr_to_const_int 修改所指向的值
const int const_value = 20;
ptr_to_const_int = &const_value; // ...也可以指向一個 const 變量

// 指針本身是可變的
int another_value = 30;
ptr_to_const_int = &another_value; // 合法：讓指針指向另一個 int (即使是 const int*)

int score = 90;
int highScore = 100;

// 4. 常量指針 (Const Pointer)
int* const const_ptr = &score; // const_ptr 是一個常量指針，它*總是*指向 score
                               // const 修飾的是 ptr 本身，不是 *ptr

*const_ptr = 95;          // 合法：可以通過常量指針修改其指向的 *非 const* 內(nèi)容
// const_ptr = &highScore; // 編譯錯誤：不能改變常量指針的指向

// 5. 指向常量的常量指針 (Const Pointer to Const)
const int MAX_SCORE = 100;
const int* const const_ptr_to_const = &MAX_SCORE; // 指針本身和它指向的內(nèi)容都是常量

// *const_ptr_to_const = 99; // 編譯錯誤：不能修改指向的 const 內(nèi)容
// const_ptr_to_const = &value; // 編譯錯誤：不能改變常量指針的指向

#include <string>
#include <vector>
#include <type_traits> // 用于 static_assert 證明等價性

// 1. 基本類型的常量
int const MAX_USERS_EAST = 1000;
static_assert(std::is_same_v<constint, intconst>, "const int == int const"); // 證明類型等價

// 2. 常量引用 (Reference to Const)
std::string const GREETING_EAST = "Hello, East!";
std::string const& ref_greeting_east = GREETING_EAST;
static_assert(std::is_same_v<const std::string&, std::string const&>, "const T& == T const&");

void printMessageEast(std::string const& msg){
    // msg = "Cannot change"; // 編譯錯誤
    std::cout << msg << std::endl;
}

// 3. 指向常量的指針 (Pointer to Const)
int const* ptr_to_const_int_east;
static_assert(std::is_same_v<constint*, intconst*>, "const int* == int const*");

int value_east = 10;
ptr_to_const_int_east = &value_east;
// *ptr_to_const_int_east = 20; // 編譯錯誤

const int x = 10; // x 本身是常量，具有頂層 const。
int* const ptr = &some_int; // ptr 本身是常量（不能改變指向），具有頂層 const。指針指向的 int 不是常量。
const std::vector<int> vec = {1, 2, 3}; // vec 本身是常量，具有頂層 const。

const int* ptr; // ptr 指向的 int 是常量，具有底層 const。ptr 本身不是常量（可以改變指向）。int const* ptr; // 同上，底層 const。
const int& ref = x; // ref 引用的 int 是常量，具有底層 const。引用本身總是“常量”（不能重新綁定），但我們通常不稱引用本身有頂層 const。
int* const* ptr_ptr; // ptr_ptr 指向一個 int* const（常量指針）。這里的 const 是底層 const (相對于 ptr_ptr 而言，它指向的對象類型中帶有 const)。
const int* const ptr; // ptr 既有頂層 const (指針本身不能改)，也有底層 const (指向的 int 不能改)。

const int a = 10;
int b = a; // 合法：a 的頂層 const 被忽略，拷貝的是值 10

int i = 0;
int* const p1 = &i; // p1 有頂層 const
int* p2 = p1;      // 合法：拷貝指針地址時，p1 的頂層 const 被忽略

const int c = 20;
const int* p_const = &c; // 底層 const
// int* p_non_const = p_const; // 編譯錯誤：不能將 const int* 賦給 int* (試圖丟棄底層 const)

int d = 30;
int* p_d = &d;
const int* p_const_d = p_d; // 合法：可以從 int* 轉(zhuǎn)換為 const int* (增加底層 const)

const int& r_const = c; // 底層 const
// int& r_non_const = r_const; // 編譯錯誤：不能將 const int& 綁定到 int&

void process(int* ptr);       // 處理非 const int 的指針
void process(const int* ptr); // 重載版本：處理 const int 的指針

int num = 1;
const int cnum = 2;
process(&num);  // 調(diào)用 process(int*)
process(&cnum); // 調(diào)用 process(const int*)

// void setup(int x);
// void setup(const int x); // 編譯錯誤：重定義。參數(shù) x 的頂層 const 在函數(shù)簽名中被忽略

// void configure(int* p);
// void configure(int* const p); // 編譯錯誤：重定義。參數(shù) p 的頂層 const 被忽略

class Widget {
public:
    void update(){ /* ... */ }      // 可以修改對象狀態(tài)
    void display()const{ /* ... */ } // 保證不修改對象狀態(tài) (this 是 const Widget*)
};

Widget w;
const Widget cw;
w.update();    // OK
w.display();   // OK, 調(diào)用 display() const
// cw.update(); // 編譯錯誤：不能在 const 對象上調(diào)用非 const 成員函數(shù)
cw.display();  // OK, 調(diào)用 display() const

template<typename T>
void foo(T param);

const int ci = 0;
foo(ci); // T 推導(dǎo)為 int (頂層 const 被忽略)

const int* pci = &ci;
foo(pci); // T 推導(dǎo)為 const int* (底層 const 被保留)

int* const cpi = &some_int;
foo(cpi); // T 推導(dǎo)為 int* (頂層 const 被忽略)

T const* ptr / const T* ptr: const 應(yīng)用于 T，是底層 const。
T* const ptr: const 應(yīng)用于 * (指針本身)，是頂層 const。
T const* const ptr / const T* const ptr: 第一個 const (靠近 T) 是底層 const，第二個 const (靠近 ptr) 是頂層 const。
const T x / T const x: const 應(yīng)用于對象 x 本身，是頂層 const。
const T& ref / T const& ref: const 應(yīng)用于 T (被引用的類型)，是底層 const。