从 const char * 到 char **:一次把 C/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"
浙公网安备 33010602011771号