C语言指针精讲（二）∶加深对指针使用，理解传址调用

#include <stdio.h> int main() { const int n = 0; printf("n = %d\n", n); int* p = &n; *p = 20; printf("n = %d\n", n); return 0; }

运行结果

结论：这里我们发现我们用n的地址就把n改了，但我们本质是让n不要被修改，那么我们就要是其拿到n的地址却不能修改它，这就是接下来要说的const修饰指针变量。

1.2 const 修饰指针变量

⼀般来讲const修饰指针变量，可以放在*的左边，也可以放在*的右边，意义是不⼀样的。

int * p;//没有const修饰？ int const * p;//const 放在*的左边做修饰 int * const p;//const 放在*的右边做修饰

我们用下面代码来分析具体分析⼀下：

#include <stdio.h> //测试const放在*的左边情况 void test2() { int n = 10; int m = 20; const int* p = &n; *p = 20;//ok? p = &m; //ok? } int main() { test2(); return 0; }

当我们编译时会发现:
*p = 20; 不允许，编译报错
const int* p 表示指针指向的数据只读，不能通过指针修改值。
p = &m; 允许，正常运行
指针变量本身可以修改，能重新指向其他地址。

总结： const 在 * 左侧 → 保护指向的内容，不保护指针本身。

#include <stdio.h> //测试const放在*的右边情况 void test3() { int n = 10; int m = 20; int * const p = &n; *p = 20; //ok? p = &m; //ok? } int main() { test3(); return 0; }

当运行时我们发现这里的运行结果刚好跟const在*右侧修饰时的时候相反
*p = 20; 允许，正常运行
int* const p 表示指向的数据可以通过指针修改值
p = &m; 编译报错
指针变量本身不可被修改，不能指向其他地址

总结： const 在 * 右侧 → 保护指针本身，不保护指向的内容。

#include <stdio.h> //测试*的左右两边都有const void test4() { int n = 10; int m = 20; int const * const p = &n; *p = 20; //ok? p = &m; //ok? } int main() { test3(); return 0; }

当运行时我们就会发现
*p＝20跟p＝&m都会报错，这就是因为const把p本身跟他所指向的内容都保护了，使他们都不能被修改。

总结： const 在 * 左侧和右侧→ 保护指针本身和它指向的内容。

因此我们会得到下面的结论

结论：const修饰指针变量的时候

const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变，但是指针变量本⾝的内容可变。

const如果放在*的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。

2.野指针

2.1 野指针成因

1.指针未初始化

#include <stdio.h> int main() { int *p;//局部变量指针未初始化，默认为随机值 *p = 20; return 0; }

2. 指针越界访问

#include <stdio.h> int main() { int arr[10] = {0}; int *p = &arr[0]; int i = 0; for(i = 0; i <= 11; i++) { //当指针指向的范围超出数组arr的范围时，p就是野指针 *(p++) = i; } return 0; }

3. 指针指向的空间释放

#include <stdio.h> int* test() { int n = 100; return &n;//这里的n是局部变量，存放在栈区，函数test运行完后，栈空间自动释放，n的内存被回收 } int main() { int*p = test();//这里p所指向的是一块已经不属于当前程序合法使用的地址 printf("%d\n", *p); return 0; }

2.2 如何规避野指针

2.2.1 指针初始化

如果明确知道指针指指向哪里就直接赋值地址，如果不知道指针应该指向哪里，可以给指针赋值NULL。
NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是无法使用的，读写该地址会报错。

初始化如下：

#include <stdio.h> int main() { int num = 10; int*p1 = &num; int*p2 = NULL; return 0; }

2.2.2 小心指针越界

⼀个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问。

2.2.3 指针变量不再使用时，及时置NULL，指针使用之前检查有效性

当指针变量指向⼀块区域的时候，我们可以通过指针访问该区域，后期不再使⽤这个指针访问空间的时候，我们可以把该指针置为NULL。因为约定俗成的⼀个规则就是：只要是NULL指针就不去访问，同时使⽤指针之前可以判断指针是否为NULL。

因此，当我们使用指针之前，我们要判断是否为NULL，如果是NULL，就不要直接使用

int main() { int arr[10] = {1,2,3,4,5,6,7,8,9,10}; int *p = &arr[0]; int i = 0; for(i = 0; i < 10; i++) { *(p++) = i; } //此时p已经越界了，可以把p置为NULL p = NULL; //下次使⽤的时候，判断p不为NULL的时候再使⽤ //... p = &arr[0];//重新让p获得地址 if(p != NULL) //判断 { //... } return 0;

2.2.4 避免返回局部变量的地址

如造成野指针的第3个例子，不要返回局部变量的地址。

3.assert 断言

assert.h头文件定义了宏assert()，用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行。这个宏常常被称为“断言”。

assert(p != NULL);

上面代码在程序运行到这⼀行语句时，验证变量p是否等于NULL。如果确实不等于NULL，程序继续运行，否则就会终止运行，并且给出报错信息提示。

assert()宏接受⼀个表达式作为参数。如果该表达式为真（返回值非零），assert()不会产生

任何作用，程序继续运行。如果该表达式为假（返回值为零），assert()就会报错，在标准错误

流stderr 中写入⼀条错误信息，显示没有通过的表达式，以及包含这个表达式的文件名和行号。

使用assert()有几个好处：它不仅能自动标识文件和 出问题的行号，还有⼀种无需更改代码就能开启或关闭 assert()的机制。如果已经确认程序没有问 题，不需要再做断言，就在 #include <assert.h>语句的前面，定义⼀个宏NDEBUG。

#define NDEBUG #include <assert.h>

然后，重新编译程序，编译器就会禁用文件中所有的 assert() 语句。如果程序⼜出现问题，可以移
除这条 #define NDEBUG 指令（或者把它注释掉），再次编译，这样就重新启⽤了 assert() 语
句。
assert() 的缺点是，因为引入了额外的检查，增加了程序的运行时间。

⼀般我们可以在 Debug 中使⽤，在 Release 版本中选择禁用assert 就行，在VS这样的集成开
发环境中，在Release 版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，
在 Release 版本不影响用户使用时程序的效率。

4. 指针的使用和传址调用

4.1 strlen的模拟实现

库函数strlen的功能是求字符串长度，统计的是字符串中 \0 之前的字符的个数。
函数原型如下：

size_t strlen ( const char * str );

分析：参数str接收⼀个字符串的起始地址，然后开始统计字符串中 \0之前的字符个数，最终返回⻓度。如果要模拟实现只要从起始地址开始向后逐个字符的遍历，只要不是 \0字符，计数器就+1，这样直到 \0就停止。

参考代码如下：

int my_strlen(const char * str) { int count = 0; assert(str); while(*str) { count++; str++; } return count; } int main() { int len = my_strlen("abcdef"); printf("%d\n", len); return 0; }

4.2 传值调用和传址调用

学习指针的目的是使用指针解决问题，那什么问题，非指针不可呢？

例如：写⼀个函数，交换两个整型变量的值

⼀番思考后，我们可能写出这样的代码：

#include <stdio.h> void Swap1(int x, int y) { int tmp = x; x = y; y = tmp; } int main() { int a = 0; int b = 0; scanf("%d %d", &a, &b); printf("交换前：a=%d b=%d\n", a, b); Swap1(a, b); printf("交换后：a=%d b=%d\n", a, b); return 0; }

运行结果如下：

我们发现其实没产生交换的效果，这是为什么呢？

调试⼀下，试试呢？

我们发现在main函数内部，创建了a和b，a的地址是0x00cffdd0，b的地址是0x00cffdc4，在调用Swap1函数时，将a和b传递给了Swap1函数，在Swap1函数内部创建了形参x和y接收a和b的值，但是x的地址是0x00cffcec，y的地址是0x00cffcf0，x和y确实接收到了a和b的值，不过x的地址和a的地址不⼀样，y的地址和b的地址不⼀样，相当于x和y是独立的空间，那么在Swap1函数内部交换x和y的值，自然不会影响a和b，当Swap1函数调⽤结束后回到main函数，a和b的没法交换。Swap1函数在使用的时候，是把变量本⾝直接传递给了函数，这种调用函数的方式我们之前在函数的时候就知道了，这种叫传值调用。

结论：实参传递给形参的时候，形参会单独创建⼀份临时空间来接收实参，对形参的修改不影响实

参。

我们现在要解决的就是当调用Swap函数的时候，Swap函数内部操作的就是main函数中的a和b，直接 将a和b的值交换了。那么就可以使用指针了，在main函数中将a和b的地址传递给Swap函数，Swap函数里边通过地址间接的操作main函数中的a和b，并达到交换的效果就好了。

#include <stdio.h> void Swap2(int*px, int*py) { int tmp = 0; tmp = *px; *px = *py; *py = tmp; } int main() { int a = 0; int b = 0; scanf("%d %d", &a, &b); printf("交换前：a=%d b=%d\n", a, b); Swap2(&a, &b); printf("交换后：a=%d b=%d\n", a, b); return 0; }

程序运行结果如下：

我们可以看到实现成Swap2的方式，顺利完成了任务，这里调用Swap2函数的时候是将变量的地址传 递给了函数，这种函数调用方式叫：传址调用。

传址调用，可以让函数和主调函数之间建立真正的联系，在函数内部可以修改主调函数中的变量；所以未来函数中只是需要主调函数中的变量值来实现计算，就可以采用传值调用。如果函数内部要修改主调函数中的变量的值，就需要传址调用。