• 博客园logo
  • 会员
  • 周边
  • 新闻
  • 博问
  • 闪存
  • 赞助商
  • Chat2DB
    • 搜索
      所有博客
    • 搜索
      当前博客
  • 写随笔 我的博客 短消息 简洁模式
    用户头像
    我的博客 我的园子 账号设置 会员中心 简洁模式 ... 退出登录
    注册 登录

利昂萧侯

  • 博客园
  • 联系
  • 订阅
  • 管理

公告

View Post

从 const char * 到 char **:一次把 C/C++ 指针与引用彻底讲透

**指针变量本身也是一块内存,它有"自己的地址 `&p`"和"存着的地址值 `p`"两层,而 `*p` 是顺着地址值找到的目标内容;`const` 放在谁旁边就锁住谁,`p[i]` 只是 `*(p+i)` 的写法,`%s` 要的是地址、`%p` 输出的是地址,多一个 `*` 就多一层间接,C++ 在此基础上新增了"引用"这个不可重绑定的别名,并收紧了字符串字面量的类型。**

总述

文章主线:指针变量本身也是一块内存,它有"自己的地址 &p"和"存着的地址值 p"两层,而 *p 是顺着地址值找到的目标内容;const 放在谁旁边就锁住谁,p[i] 只是 *(p+i) 的写法,%s 要的是地址、%p 输出的是地址,多一个 * 就多一层间接,C++ 在此基础上新增了"引用"这个不可重绑定的别名,并收紧了字符串字面量的类型。

下面按"先分清两层地址 → 再理解 const 锁谁 → 再看下标与解引用等价 → 再讲 %s/%p 的地址语义 → 再推多级指针 → 最后对比 C++ 的保留与改变"的顺序展开。

1. 指针变量的两层地址:&p、p、*p

一切困惑的根源,是把"指针自己的地址"和"指针存的值"混为一谈。先理解这三个表达式。

char a[] = "hello";
char *q = a;

// &q  指针变量自己所在地址,永远不变
// q   指针存的值(a 的地址),可不可变看 const
// *q  顺着 q 找到的字符 'h'
地址        内容
0x1000      'h'      <- a[0],*q 指向这里
0x1001      'e'
0x1002      'l'
0x1003      'l'
0x1004      'o'
0x1005      '\0'
...
0x2000      0x1000   <- q 这个变量本身
            ^
            &q = 0x2000(永远不变)
            q  = 0x1000(可不可变看 const)
            *q = 访问 0x1000 里的 'h'
表达式 类型 含义 可变性
&q char ** 指针自己的内存地址 永远不变
q char * 指向的值也就是指向的内存地址 看 const 是否挨着 q
*q char 指向的内存地址所存的内容 看 const 是否挨着 char

2. const char *p、char const *p、char * const p

const 紧挨谁就锁谁。前两者完全等价,是同一个类型。

char a[] = "hello";
char b[] = "world";

const char *p1 = a;    // 内容不可改,指针可改
char const *p2 = a;    // 与 p1 完全同类型

char * const p3 = a;   // 指针不可改,内容可改
const char * const p4 = a; // 两者都锁死

p1 = b;      // ✅ 指针可变
// p1[0] = 'H'; // ❌ 内容不可变

p3[0] = 'H'; // ✅ 内容可变
// p3 = b;   // ❌ 指针不可变

对比表:

声明 指针 p 可变? 所指内容可变? 读法
const char *p ✅ ❌ 指向 const char 的指针
char const *p ✅ ❌ 同上(等价写法)
char * const p ❌ ✅ 指向 char 的 const 指针
const char * const p ❌ ❌ 两者都锁死

记法:从右往左读;const 挨着 char 锁内容,挨着 p 锁指针。

3. q[0] 与 *q 为什么等价

理解了"内容可变",还要理解改内容的两种写法其实是同一件事。
C 语言对下标运算的定义就是:

q[i] ≡ *(q + i)

所以 q[0] ≡ *(q+0) ≡ *q,两者是同一处内容的两种写法。

char a[] = "hello";
char * const q = a;   // q 锁死指向 a,但 a 内容可改

q[0] = 'H';   // 就是 *(q+0)='H',改 a[0] → "Hello"
*q   = 'h';   // 同上,改 a[0] → "hello"
// q = b;     // ❌ 改的是指针本身,被 const 禁止

要点:q[0] 和 *q 改的都是指向的内容,不是指针;所以 char * const 允许它们、禁止 q = b。

4. %s 要地址,%c 要字符,%p 输出地址

C 里"字符串"的身份就是它的起始地址,所以"输出整串"和"给地址"是同一件事。

char a[] = "hello";
char *q = a;

printf("%s\n", q);          // hello,从 q 读到 '\0'
printf("%c\n", *q);         // h,单个字符值
printf("%p\n", (void*)q);   // q 指向哪,如 0x1000
printf("%p\n", (void*)&q);  // q 自己在哪,如 0x2000

// printf("%s\n", *q);      // ❌ 把 'h'(104) 当地址 → 段错误
// printf("%c\n", q);       // ❌ 把地址当字符 → 乱码

%s 的机制:拿到一个地址,从该地址逐字节往后读,直到遇到 '\0' 才停。

char *q2 = a + 2;
printf("%s\n", q2);   // "llo" —— 从中间开始,不是整个数组

为什么需要 (void*):%p 规范要求参数是 void *,而 printf 是变参函数、不做类型转换,char * 需手动对齐。

格式符 期望参数类型 传什么 输出什么
%s char * q 或 a 从地址到 '\0' 的整串
%c int(字符值) *q 或 q[0] 单个字符
%p void * (void)q / (void)&q 地址的十六进制

5. char * 与 char **:多一个 * 多一层间接

char  c = 'A';
char *p = &c;      // p 指向 char
char **pp = &p;    // pp 指向 char*

地址        内容        变量
0x1000      'A'         c     (char)
0x2000      0x1000      p     (char*,存 c 的地址)
0x3000      0x2000      pp    (char**,存 p 的地址)
表达式 类型 含义
c char 字符本身
p char * 指向 c
*p char 解一层 → c
pp char ** 指向 p
*pp char * 解一层 → p
**pp char 解两层 → c

可以把char c = 'A';这样的过程理解为内存里放了一个盒子,值为'A'的盒子,盒子有地址;
char *p = &c; → 又放了一个盒子 p,盒子里装的不是字符,而是写着 c 盒子地址的便签;
char **pp = &p; → 再放一个盒子 pp,盒子里装的是写着 p 盒子地址的便签。
解引用*这个动作,本质就是:把盒子里写的地址拿出来,走到那个地址,打开那个盒子。

写法 动作 走到哪 看到什么
p 不照便签走,只看便签本身 — 0x1000(一张指向 c 的便签)
*p 照 p 的便签走 1 次 0x1000 'A'
pp 只看 pp 的便签 — 0x2000(一张指向 p 的便签)
*pp 照 pp 的便签走 1 次 0x2000 0x1000(p 的内容,还是一张便签)
**pp 照便签走 2 次 0x1000 'A'

6.C++ 的保留与改变:指针不变,新增引用,收紧字面量

前五节在 C++ 中全部有效;C++ 只加了两件事——引用,和字符串字面量的类型安全。

6.1 保留:指针与 const 规则完全一致

const char *p1 = "hi";    // 内容不可改,指针可改
char * const p3 = a;      // 指针不可改,内容可改

6.2 新增:引用——必须初始化、不可重绑定、不可为空

是 C++ 新引入的一种变量类别。C 里没有"引用"这个东西。

int a = 10, b = 20;
int &r = a;    // r 是 a 的别名,必须初始化
r = 20;        // 改的是 a
// r = b;      // 不是重绑定,而是把 b 的值赋给 a
// int &r2;    // ❌ 引用必须初始化

① 引用必须初始化(int &r2; 报错);② 引用就是别名,直接改值不用 *(r = 20 改的是 a);③ 引用不能改绑,r = b 是赋值不是换绑(a 变、b 不变、&r 仍等于 &a)。
引用 vs 指针:

特性 指针 引用
必须初始化 否 是
能否改变指向 能 不能
访问方式 需 *p 隐式
是否可为空 可 nullptr 不能
多级间接 支持 char ** 只一级

6.3 简化:用"指针的引用"替代二级指针

char ** 是"char * 的地址",靠解一层 *p 间接改外面的指针;char *& 是"char * 的别名",p 直接就是外面的指针,直接改。& 替代 ** 的本质,是把"绕地址间接改"换成了"起别名直接改",省掉一层解引用,代价是引用不能改绑、不能为空。

/* ---------- C 风格:二级指针 ---------- */
void point_to_c(char **p, char *target) {
    *p = target;          /* p 是 buf 的地址,*p 解一层 = buf,改它 */
}

int main(void) {
    char buf[]    = "hello";   
    char target[] = "world";

    point_to_c(&buf, target);  /* 传 buf 的地址,类型 char** */
    printf("%s\n", buf);       /* world */

    return 0;
}
/* ---------- C++ 风格:指针的引用 ---------- */
void point_to_cpp(char *&p, char *target) {
    p = target;          /* p 就是 buf 本身,直接改 */
}

int main() {
    char buf[]    = "hello";   
    char target[] = "world";

    point_to_cpp(buf, target); /* 直接传 buf,不写 & */
    std::printf("%s\n", buf);  /* world */

    return 0;
}

6.4C++的改变

字符串字面量是 const char[]

char *p = "hello";        // C 中合法(但有风险)

char *p = "hello";        // ❌ C++ 中错误
const char *p = "hello";  // ✅ 正确

!!!注意这个改变只针对"字符串字面量"这一种特殊情况,普通字符变量是可以正常改值的。不是"C++ 指针不能改值了",而是"C++ 不许让可写指针指向只读的字符串字面量"。

char *p = "hello";        // ❌ C++ 错误

char a[] = "hello";   // 数组:可写内存,内容拷贝在栈上
char *p = a;          // ✅ 合法,a 可写
p[0] = 'H';           // ✅ 完全可以改,a 变成 "Hello"

类比:const char *p = "hello" 相当于"拿着一张标签写着'这是只读的'的便签去指那块内存";而 char *p = "hello" 相当于"拿一张承诺'我能写'的便签去指只读内存"——C++ 认为后者自相矛盾,所以禁止。

结尾

分清 &p、p、*p 三层,记住 const 挨谁锁谁、p[i] ≡ *(p+i)、%s 要地址、多一个 *多一层间接,以及 C++ 的"引用&不可重绑定 + 字面量是const"

posted on 2026-11-10 20:28  利昂萧侯  阅读(12)  评论(0)    收藏  举报

刷新页面返回顶部
 
博客园  ©  2004-2026
浙公网安备 33010602011771号 浙ICP备2021040463号-3