第 7 章指针

对应教材目录

7.1 变量与指针
7.1.1 地址与指针
7.1.2 指向变量的指针变量
7.1.3 指针变量作函数参数
7.2 数组与指针
7.2.1 指针与一维数组的联系
7.2.2 指针与二维数组的联系
7.2.3 指向数组的指针作函数参数
7.3 字符串与指针
7.3.1 字符指针变量的定义与初始化
7.3.2 字符指针作函数参数
7.4 函数与指针
7.4.1 指向函数的指针
7.4.2 返回指针的函数
7.5 指针数组和多级指针
7.5.1 指针数组
7.5.2 多级指针
7.5.3 main 函数的形参
7.6 编程实战
7.7 指针小结

本章目标

学完这一章，你应该能做到：

知道什么是地址，什么是指针。
会用 & 取地址，会用 * 访问地址中的内容。
会定义、初始化和使用最基本的指针变量。
能用指针作为函数参数，真正修改函数外部变量。
理解数组名、字符串和指针之间的联系。
能初步看懂函数指针、指针数组和二级指针。
能独立完成交换数据、遍历数组、处理字符串等基础题。

1. 为什么要学指针

指针是 C 语言最有代表性的内容之一。

前面你已经学过：

变量
数组
字符串
函数

到了这一章，你会发现它们其实都和“地址”有关。

学指针的意义主要有三个：

让函数可以间接修改外部变量。
更灵活地处理数组和字符串。
为后面的结构体、链表、动态内存等内容打基础。

一开始不要把指针想得太神秘。

你可以先把它理解成一句话：

指针就是“专门存地址的变量”。

2. 地址与指针

每个变量在内存中都有自己的存储位置，这个位置就叫地址。

例如：

1
int a = 10;

变量 a 不仅有值 10，它还有一个地址。

想得到变量地址，可以用取地址运算符 &：

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a = 10;
6
    printf("%p\n", (void *)&a);
7
    return 0;
8
}

这里的 %p 用来输出地址。

你会看到一串十六进制形式的内容，那就是 a 的地址。

这里你可能会有一个疑问：

1
printf("%p\n", &a);

和

1
printf("%p\n", (void *)&a);

有什么区别？

先说最直接的结论：

这两个写法输出出来通常是同一个地址。
地址本身没有变。
(void *) 做的是类型转换，不是“改地址”。

你可以这样理解：

&a：表示取出变量 a 的地址。
&a 的类型其实是 int *，意思是“指向 int 的指针”。
(void *)&a：表示先取出 a 的地址，再把它转成 void * 类型。

这里的 void * 可以先把它理解成“通用地址类型”。

也就是说：

int *：强调“这是一个指向整型变量的地址”
void *：强调“这是一个地址”，但先不强调它具体指向什么类型

那为什么我在笔记里写成 (void *)&a 呢？

因为 %p 是专门用来输出地址的，占位符更规范地对应 void * 类型。

所以：

1
printf("%p\n", (void *)&a);

是更标准、更严谨的写法。

但对初学阶段来说，你也可以先把它记成：

printf("%p\n", &a); 也常常能正常输出地址
printf("%p\n", (void *)&a); 只是写得更规范一些

你现在最需要记住的是：

&a 是“取地址”
(void *)&a 还是这个地址，只是把它转换成了 void *
(void *) 不是在“改值”，也不是在“改地址”，只是告诉编译器：“把这个地址当成通用地址来看”

2.1 什么是指针

如果一个变量专门用来保存地址，那么这个变量就叫指针变量。

例如：

1
int a = 10;
2
int *p = &a;

这里：

a 是普通整型变量。
&a 表示 a 的地址。
p 是一个指向 int 的指针变量。

也就是说，p 里面存的不是 10，而是 a 的地址。

2.2 `*` 的两个常见含义

这一章最容易混的就是 *。

它在不同位置，含义不一样：

int *p; 里的 *：表示 p 是一个指针变量。
*p 里的 *：表示访问 p 所指向地址中的内容。

看例子：

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a = 10;
6
    int *p = &a;
7

8
    printf("%d\n", a);
9
    printf("%d\n", *p);
10
    return 0;
11
}

输出的两个值都是 10。

这是因为：

a 直接访问变量本身
*p 是通过地址间接访问变量本身

2.3 通过指针修改变量

指针最重要的作用之一，就是可以通过地址修改变量。

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a = 10;
6
    int *p = &a;
7

8
    *p = 99;
9

10
    printf("%d\n", a);
11
    return 0;
12
}

输出结果是：

1
99

因为 p 指向 a，所以 *p = 99; 本质上就是把 a 改成了 99。

3. 指向变量的指针变量

指针变量也有自己的类型。

例如：

int *p; 表示 p 指向 int
char *p; 表示 p 指向 char
double *p; 表示 p 指向 double

类型要对应，不能乱指。

3.1 最基本的写法

1
int a = 5;
2
int *p = &a;

这是最常见的三步：

先有一个普通变量。
再定义一个对应类型的指针变量。
用地址给指针赋值。

3.2 指针重新指向别的变量

指针变量可以改变指向对象。

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a = 10;
6
    int b = 20;
7
    int *p = &a;
8

9
    printf("%d\n", *p);
10

11
    p = &b;
12
    printf("%d\n", *p);
13
    return 0;
14
}

输出为：

说明 p 一开始指向 a，后来改成指向 b。

3.3 指针没有初始化时不要使用

下面这种写法是错误的：

1
int *p;
2
*p = 10;

因为 p 这时还没有指向一个合法地址。

初学阶段你可以记住一个规则：

先让指针指向一个确定对象，再使用 *p

如果一开始还不确定指向哪里，可以先写成：

1
int *p = NULL;

但这里一定要特别注意：

NULL 的意思是“空指针”
它表示 p 目前没有指向任何有效对象
所以这时候仍然不能直接使用 *p

下面这种写法仍然是错误的：

1
int *p = NULL;
2
*p = 10;
3
printf("%d\n", *p);

它会在运行时直接报错

所以你可以把 NULL 理解成：

先给指针一个“明确的空状态”
方便后面再判断、再赋真正的地址
但不是说写成 NULL 以后就能直接通过 *p 访问数据

正确写法应该是先让它指向一个合法变量，再使用：

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a = 10;
6
    int *p = NULL;
7

8
    p = &a;
9
    *p = 20;
10

11
    printf("%d\n", *p);
12
    printf("%d\n", a);
13
    return 0;
14
}

输出为：

因为在 p = &a; 之后，p 才真正指向了一个合法地址。

4. 指针变量作函数参数

前面你学函数时已经知道：普通参数传递是值传递。

也就是说，函数拿到的是副本，不是原变量本身。

所以如果这样写交换函数：

1
void swap(int a, int b)
2
{
3
    int t = a;
4
    a = b;
5
    b = t;
6
}

它并不能真正交换主函数中的两个变量。

想真正修改外面的变量，就要把地址传进去。

4.1 交换两个变量

1
#include <stdio.h>
2

3
void swap(int *a, int *b)
4
{
5
    int t = *a;
6
    *a = *b;
7
    *b = t;
8
}
9

10
int main(void)
11
{
12
    int x = 3;
13
    int y = 5;
14

15
    swap(&x, &y);
16

17
    printf("%d %d\n", x, y);
18
    return 0;
19
}

输出为：

1
5 3

这里一定要看清两层意思：

调用时写 swap(&x, &y)，传进去的是地址。
函数里写 *a、*b，改的是地址里的真实内容。

4.2 用指针参数让函数“带回多个结果”

有时一个函数不仅要算结果，还想顺便把别的信息也带回来，这时也常用指针参数。

例如：求两个数的较大值和较小值。

1
#include <stdio.h>
2

3
void get_max_min(int a, int b, int *max, int *min)
4
{
5
    if (a > b)
6
    {
7
        *max = a;
8
        *min = b;
9
    }
10
    else
11
    {
12
        *max = b;
13
        *min = a;
14
    }
15
}
16

17
int main(void)
18
{
19
    int max, min;
20
    get_max_min(8, 3, &max, &min);
21
    printf("%d %d\n", max, min);
22
    return 0;
23
}

5. 数组与指针

数组和指针的关系，是这一章最核心的部分。

5.1 指针与一维数组的联系

在大多数表达式中，数组名可以看成数组首元素的地址。

例如：

1
int a[5] = {10, 20, 30, 40, 50};

这里数组名 a，很多时候就相当于 &a[0]。

所以：

a[0] 等价于 *a
a[1] 等价于 *(a + 1)
a[i] 等价于 *(a + i)

看例子：

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a[5] = {10, 20, 30, 40, 50};
6
    int *p = a;
7

8
    printf("%d\n", a[0]);
9
    printf("%d\n", *p);
10
    printf("%d\n", *(p + 2));
11
    printf("%d\n", p[3]);
12
    return 0;
13
}

输出为：

5.2 用指针遍历一维数组

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a[5] = {1, 2, 3, 4, 5};
6
    int *p = a;
7

8
    while (p < a + 5)
9
    {
10
        printf("%d ", *p);
11
        p++;
12
    }
13
    return 0;
14
}

这里的 p++ 不是地址只加 1 个字节，而是自动移动到下一个同类型元素。

也就是说：

int * 每次跳到下一个整数位置
char * 每次跳到下一个字符位置

5.3 指针与二维数组的联系

二维数组稍微难一点。

例如：

1
int a[2][3] = {
2
    {1, 2, 3},
3
    {4, 5, 6}
4
};

这里：

a 表示第一行的地址
a + 1 表示第二行的地址

如果写成指针形式，通常是：

1
int (*p)[3] = a;

注意这里的 p 不是“指向单个整数”，而是“指向一行有 3 个整数的数组”。

看例子：

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a[2][3] = {
6
        {1, 2, 3},
7
        {4, 5, 6}
8
    };
9
    int (*p)[3] = a;
10

11
    printf("%d\n", a[1][2]);
12
    printf("%d\n", p[1][2]);
13
    printf("%d\n", *(*(a + 1) + 2));
14
    return 0;
15
}

三个输出都是 6。

5.4 指向数组的指针作函数参数

对一维数组来说，下面两种写法常常等价：

1
int sum(int a[], int n)

1
int sum(int *a, int n)

例如：

1
int sum(int *a, int n)
2
{
3
    int i, s = 0;
4
    for (i = 0; i < n; i++)
5
        s += *(a + i);
6
    return s;
7
}

对于二维数组，列数通常要写清楚：

1
void print_matrix(int a[][3], int rows)
2
{
3
    int i, j;
4
    for (i = 0; i < rows; i++)
5
    {
6
        for (j = 0; j < 3; j++)
7
            printf("%d ", a[i][j]);
8
        printf("\n");
9
    }
10
}

6. 字符串与指针

字符串本质上就是以 '\0' 结尾的一串字符。

所以它和指针关系非常紧密。

6.1 字符指针变量的定义与初始化

先看两种常见写法：

1
char str1[] = "hello";
2
char *str2 = "hello";

它们看起来很像，但不是一回事：

str1 是字符数组。
str2 是字符指针，指向字符串常量的首字符。

字符数组中的内容通常可以改：

1
str1[0] = 'H';

但像下面这种写法，初学阶段不要去改：

1
str2[0] = 'H';

因为它指向的是字符串常量，修改它通常是不安全的。

6.2 用字符指针遍历字符串

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    char str[] = "sunshine";
6
    char *p = str;
7

8
    while (*p != '\0')
9
    {
10
        printf("%c ", *p);
11
        p++;
12
    }
13
    return 0;
14
}

输出为：

1
s u n s h i n e

6.3 字符指针作函数参数

字符串处理函数经常写成这种形式：

1
int my_strlen(char *s)
2
{
3
    int len = 0;
4
    while (*s != '\0')
5
    {
6
        len++;
7
        s++;
8
    }
9
    return len;
10
}

完整例子：

1
#include <stdio.h>
2

3
int my_strlen(char *s)
4
{
5
    int len = 0;
6
    while (*s != '\0')
7
    {
8
        len++;
9
        s++;
10
    }
11
    return len;
12
}
13

14
int main(void)
15
{
16
    char str[] = "hello";
17
    printf("%d\n", my_strlen(str));
18
    return 0;
19
}

再看一个把字符串改成大写的例子：

1
#include <stdio.h>
2

3
void to_upper(char *s)
4
{
5
    while (*s != '\0')
6
    {
7
        if (*s >= 'a' && *s <= 'z')
8
            *s = *s - 'a' + 'A';
9
        s++;
10
    }
11
}
12

13
int main(void)
14
{
15
    char str[] = "hello c";
16
    to_upper(str);
17
    printf("%s\n", str);
18
    return 0;
19
}

7. 函数与指针

7.1 指向函数的指针

函数也有入口地址，所以也可以用指针保存。

例如：

1
int add(int a, int b)
2
{
3
    return a + b;
4
}
5

6
int (*pf)(int, int);
7
pf = add;

这里的 pf 就是一个函数指针。

它表示：

pf 指向一个函数
这个函数有两个 int 参数
返回值也是 int

完整例子：

1
#include <stdio.h>
2

3
int add(int a, int b)
4
{
5
    return a + b;
6
}
7

8
int sub(int a, int b)
9
{
10
    return a - b;
11
}
12

13
int main(void)
14
{
15
    int (*pf)(int, int);
16

17
    pf = add;
18
    printf("%d\n", pf(8, 3));
19

20
    pf = sub;
21
    printf("%d\n", pf(8, 3));
22
    return 0;
23
}

7.2 返回指针的函数

函数也可以返回一个指针。

例如：返回数组中最大元素的地址。

1
int *find_max(int a[], int n)
2
{
3
    int i;
4
    int k = 0;
5

6
    for (i = 1; i < n; i++)
7
    {
8
        if (a[i] > a[k])
9
            k = i;
10
    }
11
    return &a[k];
12
}

调用后可以通过返回的指针继续访问那个元素。

1
#include <stdio.h>
2

3
int *find_max(int a[], int n)
4
{
5
    int i;
6
    int k = 0;
7

8
    for (i = 1; i < n; i++)
9
    {
10
        if (a[i] > a[k])
11
            k = i;
12
    }
13
    return &a[k];
14
}
15

16
int main(void)
17
{
18
    int a[5] = {3, 8, 2, 9, 6};
19
    int *p = find_max(a, 5);
20
    printf("%d\n", *p);
21
    return 0;
22
}

这里一定要记住一个经典陷阱：

不要返回局部变量的地址。

下面这种写法是错误的：

1
int *wrong(void)
2
{
3
    int a = 10;
4
    return &a;
5
}

因为函数结束后，局部变量 a 已经失效了。

8. 指针数组和多级指针

8.1 指针数组

指针数组就是“数组里的每个元素都是指针”。

例如：

1
char *names[3] = {"Tom", "Alice", "Bob"};

这里：

names 是数组
names[0]、names[1]、names[2] 都是字符指针

可以这样输出：

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    char *names[3] = {"Tom", "Alice", "Bob"};
6
    int i;
7

8
    for (i = 0; i < 3; i++)
9
        printf("%s\n", names[i]);
10

11
    return 0;
12
}

这个写法特别适合保存多个字符串。

8.2 多级指针

如果一个指针变量本身也有地址，那么还可以再定义一个“指向指针的指针”。

例如：

1
int a = 10;
2
int *p = &a;
3
int **pp = &p;

这里：

p 指向 a
pp 指向 p

所以：

a 是值
*p 是值
**pp 也是值

例子：

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a = 10;
6
    int *p = &a;
7
    int **pp = &p;
8

9
    **pp = 30;
10

11
    printf("%d\n", a);
12
    return 0;
13
}

输出为：

1
30

8.3 `main` 函数的形参

你以前常写的是：

1
int main(void)

但 main 还可以写成：

1
int main(int argc, char *argv[])

这里：

argc 表示命令行参数个数
argv 是一个指针数组，每个元素都是一个字符串

例如：

1
#include <stdio.h>
2

3
int main(int argc, char *argv[])
4
{
5
    int i;
6
    for (i = 0; i < argc; i++)
7
        printf("%s\n", argv[i]);
8
    return 0;
9
}

如果运行程序时后面跟了额外参数，它们都会保存在 argv 里。

9. 编程实战

下面给你几个比前面更完整一点的例子。

9.1 用两个指针逆序数组

1
#include <stdio.h>
2

3
void reverse(int a[], int n)
4
{
5
    int *left = a;
6
    int *right = a + n - 1;
7

8
    while (left < right)
9
    {
10
        int t = *left;
11
        *left = *right;
12
        *right = t;
13
        left++;
14
        right--;
15
    }
16
}
17

18
int main(void)
19
{
20
    int a[6] = {1, 2, 3, 4, 5, 6};
21
    int i;
22

23
    reverse(a, 6);
24

25
    for (i = 0; i < 6; i++)
26
        printf("%d ", a[i]);
27

28
    return 0;
29
}

9.2 用字符指针统计元音字母个数

1
#include <stdio.h>
2

3
int count_vowel(char *s)
4
{
5
    int cnt = 0;
6

7
    while (*s != '\0')
8
    {
9
        if (*s == 'a' || *s == 'e' || *s == 'i' || *s == 'o' || *s == 'u' ||
10
            *s == 'A' || *s == 'E' || *s == 'I' || *s == 'O' || *s == 'U')
11
            cnt++;
12
        s++;
13
    }
14
    return cnt;
15
}
16

17
int main(void)
18
{
19
    char str[] = "Hello Sunshine";
20
    printf("%d\n", count_vowel(str));
21
    return 0;
22
}

9.3 用函数指针做简单计算器

1
#include <stdio.h>
2

3
int add(int a, int b)
4
{
5
    return a + b;
6
}
7

8
int mul(int a, int b)
9
{
10
    return a * b;
11
}
12

13
int calc(int x, int y, int (*f)(int, int))
14
{
15
    return f(x, y);
16
}
17

18
int main(void)
19
{
20
    printf("%d\n", calc(2, 3, add));
21
    printf("%d\n", calc(2, 3, mul));
22
    return 0;
23
}

10. 指针小结

学到这里，你至少要抓住下面这些主线：

指针是“保存地址的变量”。
& 用来取地址，* 用来访问地址中的内容。
数组名在很多情况下可以看成首元素地址。
字符串经常通过字符指针来处理。
指针作函数参数时，可以间接修改外部变量。
函数指针保存的是函数入口地址。
二级指针本质上是“指向指针的指针”。

如果这些主线你已经抓住了，第七章就算过了第一关。

11. 本章常见模板

11.1 交换两个整数

1
void swap(int *a, int *b)
2
{
3
    int t = *a;
4
    *a = *b;
5
    *b = t;
6
}

11.2 用指针遍历数组

1
int *p = a;
2
while (p < a + n)
3
{
4
    printf("%d ", *p);
5
    p++;
6
}

11.3 计算字符串长度

1
int my_strlen(char *s)
2
{
3
    int len = 0;
4
    while (*s != '\0')
5
    {
6
        len++;
7
        s++;
8
    }
9
    return len;
10
}

11.4 返回数组最大值地址

1
int *find_max(int a[], int n)
2
{
3
    int i, k = 0;
4
    for (i = 1; i < n; i++)
5
    {
6
        if (a[i] > a[k])
7
            k = i;
8
    }
9
    return &a[k];
10
}

11.5 用指针逆序数组

1
void reverse(int a[], int n)
2
{
3
    int *left = a;
4
    int *right = a + n - 1;
5
    while (left < right)
6
    {
7
        int t = *left;
8
        *left = *right;
9
        *right = t;
10
        left++;
11
        right--;
12
    }
13
}

12. 本章最容易错的点

把 int *p 里的 * 和 *p 里的 * 混成一个意思。
忘记给指针赋地址，就直接使用 *p。
该传地址时没传地址，例如把 swap(x, y) 写成不带 &。
以为数组名和普通变量完全一样，乱做赋值。
二维数组指针写错，把 int (*p)[3] 写成 int *p。
把字符数组和字符指针当成完全一样的东西。
试图修改字符串常量。
返回局部变量地址。
把指针数组和“数组指针”混在一起。

13. 手写题

写结果题

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a = 10;
6
    int *p = &a;
7
    *p = 20;
8
    printf("%d %d\n", a, *p);
9
    return 0;
10
}

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a[4] = {1, 2, 3, 4};
6
    int *p = a;
7
    printf("%d %d %d\n", *p, *(p + 2), p[3]);
8
    return 0;
9
}

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    char str[] = "abc";
6
    char *p = str;
7
    printf("%c %c %c\n", *p, *(p + 1), *(p + 2));
8
    return 0;
9
}

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a = 5;
6
    int *p = &a;
7
    int **pp = &p;
8
    **pp = 8;
9
    printf("%d %d %d\n", a, *p, **pp);
10
    return 0;
11
}

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
int add(int a, int b)
4
{
5
    return a + b;
6
}
7

8
int main(void)
9
{
10
    int (*pf)(int, int) = add;
11
    printf("%d\n", pf(2, 3));
12
    return 0;
13
}

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a[3] = {10, 20, 30};
6
    int *p = a;
7
    p++;
8
    printf("%d\n", *p);
9
    return 0;
10
}

手写程序题

定义一个整型变量和一个指向它的指针变量，分别输出该变量的值和地址。
写函数 swap(int *a, int *b)，交换两个整数的值。
写函数 order(int *a, int *b)，让两个整数按从小到大排列。
写函数 sum(int *a, int n)，用指针求数组元素之和。
写函数统计数组中正数、负数和 0 的个数，结果通过指针参数带回。
写函数返回数组中最大元素的地址，并在主函数中输出该元素值。
用指针实现一维数组逆序。
用指针统计数组中奇数元素的个数。
写函数 my_strlen(char *s)，自己实现求字符串长度。
写函数 copy_str(char *to, char *from)，用指针复制字符串。
写函数 cmp_str(char *s1, char *s2)，比较两个字符串是否相同。
写函数把字符串中的小写字母全部改成大写字母。
写函数统计一个字符串中元音字母的个数。
输入一个字符串，利用字符指针逆序输出。
写函数输出二维数组所有元素，并把二维数组作为函数参数传入。
写函数求二维数组每一行的和。
写函数 select(int op)，返回不同的函数指针，用来实现加法或乘法。
定义一个指针数组，保存 5 个字符串，并逐行输出。
用二级指针交换两个字符指针变量的值。
编写 main(int argc, char *argv[]) 程序，输出所有命令行参数。
输入若干整数，利用指针找出最大值和最小值，并输出它们的地址。
写函数利用指针实现选择排序或冒泡排序。

改错题

找出并改正下面程序中的错误。

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int *p;
6
    *p = 10;
7
    printf("%d\n", *p);
8
    return 0;
9
}

找出并改正下面程序中的错误。

1
int *f(void)
2
{
3
    int a = 100;
4
    return &a;
5
}

找出并改正下面程序中的错误。

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    char *p = "hello";
6
    p[0] = 'H';
7
    printf("%s\n", p);
8
    return 0;
9
}

找出并改正下面程序中的错误。

1
#include <stdio.h>
2

3
void swap(int *a, int *b)
4
{
5
    int t = *a;
6
    *a = *b;
7
    *b = t;
8
}
9

10
int main(void)
11
{
12
    int x = 3, y = 5;
13
    swap(x, y);
14
    printf("%d %d\n", x, y);
15
    return 0;
16
}

14. 自测清单

我知道指针的本质是“保存地址”。
我能说清楚 & 和 * 的作用。
我会定义并初始化一个最基本的指针变量。
我知道为什么指针参数能改到函数外部变量。
我能解释 a[i] 和 *(a + i) 的关系。
我能用字符指针遍历字符串。
我能看懂最基础的函数指针和二级指针写法。

15. 学习建议

第 7 章一定不要只看，必须手敲。
每次写指针题，都先问自己三件事：它指向谁、现在存的是什么地址、* 取出来的到底是谁的值。
只要你一糊涂，就把变量、地址、指针关系画出来。
指针和数组题不要跳步骤，先写下标版，再改成指针版。
如果一道题同时出现 *、数组和函数参数，不要慌，拆开逐个看。

学完这一章后，你对 C 语言的理解会明显上一个台阶，因为很多以前“只是会写”的东西，到这里才算真正看懂底层关系。

第 7 章 指针

对应教材目录

本章目标

1. 为什么要学指针

2. 地址与指针

2.1 什么是指针

2.2 * 的两个常见含义

2.3 通过指针修改变量

3. 指向变量的指针变量

3.1 最基本的写法

3.2 指针重新指向别的变量

3.3 指针没有初始化时不要使用

4. 指针变量作函数参数

4.1 交换两个变量

4.2 用指针参数让函数“带回多个结果”

5. 数组与指针

5.1 指针与一维数组的联系

5.2 用指针遍历一维数组

5.3 指针与二维数组的联系

5.4 指向数组的指针作函数参数

6. 字符串与指针

6.1 字符指针变量的定义与初始化

6.2 用字符指针遍历字符串

6.3 字符指针作函数参数

7. 函数与指针

7.1 指向函数的指针

7.2 返回指针的函数

8. 指针数组和多级指针

8.1 指针数组

8.2 多级指针

8.3 main 函数的形参

9. 编程实战

9.1 用两个指针逆序数组

9.2 用字符指针统计元音字母个数

9.3 用函数指针做简单计算器

10. 指针小结

11. 本章常见模板

11.1 交换两个整数

11.2 用指针遍历数组

11.3 计算字符串长度

11.4 返回数组最大值地址

11.5 用指针逆序数组

12. 本章最容易错的点

13. 手写题

写结果题

手写程序题

改错题

14. 自测清单

15. 学习建议

第 7 章指针

2.2 `*` 的两个常见含义

8.3 `main` 函数的形参