指针相关知识点（二）

一、const修饰指针

1.1 const修饰变量

变量是可以修改的，如果把变量的地址交给一个指针变量，通过指针变量也可以修改这个变量。而const的作用是在这个修改的基础上增加一些限制。

int main()
{
int m = 0;
m = 20;//m是可以修改的
const int n = 0;
n = 20;//n是不能被修改的
return 0;
}

上述代码中n是不能被修改的，其实n本质是变量，只不过被const修饰后，在语法上加了限制，只要我们在代码中对n就⾏修改，就不符合语法规则，就报错，致使没法直接修改n。

1.2 const修饰指针变量

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

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

void test1()
{
int n = 10;
int m = 20;
int* p = &n; //无const修饰的情况
*p = 20;
p = &m;
}

void test2()
{
int n = 10;
int m = 20;
const int* p = &n; //const放在*的左边
*p = 20;
p = &m;
}

void test3()
{
int n = 10;
int m = 20;
int* const p = &n; //const放在*的右边
*p = 20;
p = &m;
}

void test4()
{
int n = 10;
int m = 20;
int const * const p = &n; //*的两边都有const
*p = 20;
p = &m;
}

int main()
{
test1();
test2();
test3();
test4();
}
//const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容
//不能通过指针来改变，但是指针变量本身的内容可变。
//const如果放在*的右边，修饰的是指针变量本身，保证了指针变量的内容
//不能修改，但是指针指向的内容，可以通过指针改变。

二、野指针

野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）。

2.1 野指针成因

2.2.1 指针未初始化

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

2.2.2 指针越界访问

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;
}

2.2.3 指针指向的空间释放

int* test()
{
int n = 100;
return &n;
}
int main()
{
int* p = test();
printf("%d\\n", *p);
return 0;
}

2.2 如何规避野指针

2.2.1 指针初始化

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

int main()
{
int num = 10;
int*p1 = &num;
int*p2 = NULL;
return 0;
}

2.2.2 指针越界

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

2.2.3 指针变量使用前后注意点

当指针变量指向⼀块区域的时候，我们可以通过指针访问该区域，后期不再使用这个指针访问空间的时候，我们可以把该指针置为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;
}

三、指针的使用和传址调用

3.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("abcdefgh");
printf("%d\\n", len);
return 0;
}

3.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的地址是0x008ffe7c，b的地址是0x008ffe70，在调用

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

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

参。所以Swap1是失败的了。

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

//传址调用，swap1函数是将变量的地址传递给了函数
void swap1(int* p1, int* p2)
{
int tmp = 0;
tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
int main()
{
int a = 0;
int b = 0;
scanf_s("%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;
}

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

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