【C/C++】const pointer & pointer to const

關鍵詞:常數指標和指標常數常量指针与指针常量

const int p = 3;
const int* p = &a;
int const* p = 3;
int* const p = &a;

這幾種寫法究竟有什麼差別,是面試中常常會問的問題。這篇筆記將寫下關於這個問題的幾種記憶法、理解法,分別是名稱記憶法英文記憶法,以及程式記憶法


常數指標和指標常數

名稱記憶法

  1. 中文:把 const 讀成常數,把 * 讀成指標,由前往後念
  2. 英文:把 const 讀成 const,把 * 讀成 pointer (to),由後往前念
const int* p = &a;    // 常數指標(pointer to const)
int const* p = 3;     // 常數指標(pointer to const)
                      // 顧名思義,是指向常數的指標
                      // 不能通過 *p 改變指向的值,否則 *p 就不是常數了
                      // 例如:*p = 6 將出現錯誤

int* const p = &a;    // 指標常數(const pointer)
                      // 顧名思義,是一個指標的常數
                      // 不能改變 p 值,否則 p 這個指標就不是常數了
                      // 例如:p = &b 將出現錯誤

常數指標,就是常數的指標,指向常數,指向的值不可更改。對應的英文是倒過來的 pointer to const

指標常數,就是指標的常數,指標本身為常數,指向不可更改。對應的英文是倒過來的 const pointer

用英文理解會更簡單一點。

英文記憶法

  1. 將程式由後往前
  2. 將 * 替換成自然語言 pointer to
  3. 將變數後面加上 is a
const int p = 3;      // p is a int const
                      // 例如:p = 6 將出現錯誤

const int* p = &a;    // p is a pointer to int const
int const* p = 3;     // p is a pointer to const int
                      // p 是一個指向常數 int 的指標
                      // 不能通過 *p 改變指向的值,否則 *p 就不是常數了
                      // 例如:*p = 6 將出現錯誤

int* const p = &a;    // p is a const pointer to int
                      // p 是一個指向 int 的常數指標
                      // 不能改變 p 值,否則 p 這個指標就不是常數了
                      // 例如:p = &b 將出現錯誤

程式記憶法

  1. 忽略類型,只關注 * 是否在 const 後。如果是表示 *p 為常數,否則 p 為常數
const int p = 3;      // p 是常數,初始化後不能更改
                      // 例如:p = 6 將出現錯誤

const int* p = &a;    // *p 是常數,不能通過 *p 改變指向地址的內容
int const* p = 3;     // *p 是常數,不能通過 *p 改變指向地址的內容
                      // 否則 *p 就不是常數了
                      // 例如:*p = 6 將出現錯誤

int* const p = &a;    // p 是常數,初始化後不能更改其指向的地址
                      // 例如:p = &b 將出現錯誤

常量指针与指针常量

名称记忆法

  1. 中文:把 const 读成常量,把 * 读成指针,由前往后念
  2. 英文:把 const 读成 const,把 * 读成 pointer (to),由后往前念
const int* p = &a;    // 常量指针(pointer to const)
int const* p = 3;     // 常量指针(pointer to const)
                      // 顾名思义,是指向常量的指针
                      // 不能通过 *p 改变指向的值,否则 *p 就不是常量了
                      // 例如:*p = 6 将出现错误

int* const p = &a;    // 指针常量(const pointer)
                      // 顾名思义,是一个指针的常量
                      // 不能改变 p 值,否则 p 这个指标就不是常量了
                      // 例如:p = &b 将出现错误

常量指针,就是常量的指针,指向常量,指向的值不可更改。对应的英文是倒过来的 pointer to const

指针常量,就是指针的常量,指针本身为常量,指向不可更改。对应的英文是倒过来的 const pointer

用英文理解会更简单一点。

英文记忆法

  1. 将程序由后往前念
  2. 将 * 替换成自然语言 pointer to
  3. 将变量后面加上 is a
const int p = 3;      // p is a int const
                      // 例如:p = 6 将出现错误

const int* p = &a;    // p is a pointer to int const
int const* p = 3;     // p is a pointer to const int
                      // p 是一个指向常量 int 的指针
                      // 不能通过 *p 改变指向的值,否则 *p 就不是常量了
                      // 例如:*p = 6 将出现错误

int* const p = &a;    // p is a const pointer to int
                      // p 是一个指向 int 的常量指针
                      // 不能改变 p 值,否则 p 这个指标就不是常量了
                      // 例如:p = &b 将出现错误

程序记忆法

  1. 忽略类型,只关注 * 是否在 const 后。如果是表示 *p 为常量,否则 p 为常量
const int p = 3;      // p 是常量,初始化后不能更改
                      // 例如:p = 6 将出现错误

const int* p = &a;    // *p 是常量,不能通过 *p 改变指向地址的内容
int const* p = 3;     // *p 是常量,不能通过 *p 改变指向地址的内容
                      // 否则 *p 就不是常量了
                      // 例如:*p = 6 将出现错误

int* const p = &a;    // p 是常量,初始化后不能更改其指向的地址
                      // 例如:p = &b 将出现错误
分享你的喜歡

發佈留言

發佈留言必須填寫的電子郵件地址不會公開。 必填欄位標示為 *