C语言指针基础（二）

1. const修饰指针

1.1const修饰变量

变量是可以修改的，如果将一个变量的地址交给指针变量，通过指针变量就能修改这个变量。
但是我们希望给变量增加一些限制使这个变量不能被修改，这就要用到const。

#include<stdio.h>
int main()	
{
   int m =0;
   m = 20;
   const int  n =0;
   n =20;
   return 0;
}

上面的代码中的n是不能被修改的，其实就是n本质就是变量，只是被const修饰后，在语法上加上了
限制，只要我们在代码中修改变量，就不符合语法规则，就会报错，使n无法修改。

但是我们绕过n，去使用n的地址，是能够修改n的。

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

运行结果如下：

1.2 const修饰指针变量

#include <stdio.h>
//代码1
void test1()
{
 int n = 10;
 int m = 20;
 int *p = &n;
 *p = 20;//ok?
 p = &m; //ok?
}
void test2()
{
 //代码2
 int n = 10;
 int m = 20;
 const int* p = &n;
 *p = 20;//ok?
 p = &m; //ok?
}
void test3()
{
 int n = 10;
 int m = 20;
 int *const p = &n;
 *p = 20; //ok?
 p = &m; //ok?
}
void test4()
{
 int n = 10;
 int m = 20;
 int const * const p = &n;
 *p = 20; //ok?
 p = &m; //ok?
}
int main()
{
 //测试⽆const修饰的情况
 test1();
 //测试const放在*的左边情况
 test2();
 //测试const放在*的右边情况
 test3();
 //测试*的左右两边都有const
 test4();
 return 0;
}

结论：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;
}
int main()
{
 int*p = test();
 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。

int main()
{
 int arr[10] = {1,2,3,4,5,67,7,8,9,10};
 int *p = &arr[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. assert断言

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

 assert(p != NULL);

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

assert() 宏接受⼀个表达式作为参数。如果该表达式为真（返回值⾮零）， assert() 不会产⽣任何作⽤，程序继续运⾏。如果该表达式为假（返回值为零）， assert() 就会报错，在标准错误流 stderr 中写⼊⼀条错误信息，显⽰没有通过的表达式，以及包含这个表达式的⽂件名和⾏号。

assert() 的使⽤对程序员是⾮常友好的，使⽤ assert() 有⼏个好处：它不仅能⾃动标识⽂件和出问题的⾏号，还有⼀种⽆需更改代码就能开启或关闭 assert() 的机制。如果已经确认程序没有问题，不需要再做断⾔，就在 #include <assert.h> 语句的前⾯，定义⼀个宏 NDEBUG 。

#define NDEBUG
#include <assert.h>

然后，重新编译程序，编译器就会禁⽤⽂件中所有的 assert() 语句。如果程序⼜出现问题，可以移除这条 #define NDBUG 指令（或者把它注释掉），再次编译，这样就重新启⽤了 assert() 语句。

assert() 的缺点是，因为引⼊了额外的检查，增加了程序的运⾏时间。
⼀般我们可以在debug中使⽤，在release版本中选择禁⽤assert就⾏，
在V这样的集成开发环境中，在release版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，在release版本不
影响⽤⼾使⽤时程序的效率。

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

4.1传址调⽤

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

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

运行结果如下：

我们在这里发现并没有发生交换的效果。Why？？？

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

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

那该如何解决呢？
我们需要解决的是当调用函数Swap1函数时，Swap1函数内部操作的就是main函数中的a和b，将a和b的值交换。在这里我们可以使用指针在main函数中将a和b的地址传给Swap1函数，Swap1函数⾥边通过地址间接的操作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);
  Swap1(&a, &b);
  printf("交换后：a=%d b=%d\n", a, b);
  return 0;
}

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