C语言指针详解--1

###  指针是C语言中极其重要的知识点，理解并能熟练运用指针可以大大增强我们的编程能力，指针相对来说是有难度的，但通过循循渐进的学习，终究会有所进步。

##  指针概念说明以及相关注意事项、使用规范方法：

# 指针是对变量地址的访问，每一个变量创建时都会再内存上开辟空间，我们想要访问这个空间，就需要指针的帮助；创建一个指针变量的形式是变量类型加上*，但具体写法根据变量的不同而变化，指针变量对应的是内存空间，我们要在变亮前面加上&则是取到了一个地址；指针的大小是4个字节（32位平台）或是8个字节（64位平台）

#  代码说明：

int a=0;
int* p=&a;

char a='a';
char* p=&a;

int arr[3]={1,2,3};
int (*p)[3]=&arr;

其中，除去指针变量的名称就是指针变量的类型，例如int* 、int（*）[3];这些类型表示了指针指向的是什么型的内容，int* 就是指向int型的变量，依次类推；

#解引用：解引用是对指针指向内容访问的表现形式，想要改变一个变量的值，可以利用解引用先找到这个变量的地址，再在这个地址代表的空间上面改变内存上面存储的内容

int main()
{
 int a = 100;
 int* pa = &a;
 *pa = 0;
 return 0;
}

上面的代码就使用了解引用操作符，  *pa 的意思就是通过pa中存放的地址，找到指向的空间，

*pa其实就是a变量了；所以*pa = 0，这个操作符是把a改成了0.这样写增加了代码的灵活性；

# 指针指向变量的大小也确定了指针一次能操作几个字节：

#include <stdio.h>
int main()
{
 int n = 0x11223344;
 int *pi = &n; 
 *pi = 0; 
 return 0;}

#include <stdio.h>
int main()
{
 int n = 0x11223344;
 char *pc = (char *)&n;
 *pc = 0;
return 0;
}

调试我们可以看到，代码1会将n的4个字节全部改为0，但是代码2只是将n的第⼀个字节改为0。

#  指针加减整数

#include <stdio.h>
int main()
{
 int n = 10;
 char *pc = (char*)&n;
 int *pi = &n;
 
 printf("%p\n", &n);
 printf("%p\n", pc);
 printf("%p\n", pc+1);
 printf("%p\n", pi);
 printf("%p\n", pi+1);
 return 0;
}

我们可以看出 char类型指针加1跳过一个字节，int型指针加一跳过4个字节；指针的类型决定了指针向前或是向后走一步是多大的距离（单位字节）

#  void*指针：

该类型指针也叫泛型指针，可以接受任何变量的地址，在作为函数实参为指针时，可以将形参用void*来接受；

该指针类型没有大小，这也就决定了它无法进行加减整数的局限性；但是它任然很重要；

# const修饰指针：

const放在*的左边表示修饰了指针指向的内容，那么指针指向的内容就不会被改变，但是指针本身的内容可以被改变；const放在*右边表示修饰指针本身，那么指针就不能被改变，但是指针指向的内容可以被改变；若是*左边右边都有const来修饰，那么则说明指针本身和其指向内容均不能被改变；

# 指针和指针的运算：

指针减去指针的绝对值就是这两个指针之间的元素数量；

指针关系的运算：

//指针的关系运算
#include <stdio.h>
int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,10};
 int *p = &arr[0];
 int i = 0;
 int sz = sizeof(arr)/sizeof(arr[0]);
 while(p<arr+sz) //指针的⼤⼩⽐较
 {
 printf("%d ", *p);
 p++;
 }
 return 0;
}

可以看出，指针也是可以比较大小的；

# 野指针：

在使用指针时，难免会出现不规范的情况，其中野指针便是不规范使用的一种；

野指针分为三种类型：1 指针未初始化；2 指针越界访问；3 指针指向的空间释放

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


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


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

第三种就是在函数结束时，返回的是局部变量的地址，内容已经释放，那么int* p则接收不到

那么如何规避野指针呢？首先注意指针的初始化，然后那些我们暂时不使用的指针，可以将其指向NULL，因为规定了指向NULL的指针就不会去使用，那么就不会出现野指针，其次避免返回局部变量的地址；

# 传值调用和传址调用：

传值时在函数里面无法改变实参，因为传递的是值；传址时，传递的是实参的地址，而通过地址我们可以直接访问变量，这个时候就可以改变实参；

### 指针和数组：

指针和数组有着许多联系，两者联合着学习十分重要；

#数组名的理解：

数组名代表的是首元素的地址，&arr[0]和arr的含义相同；但是存在两个例外，就是sizeof(arr)和&arr，这两个地方的数组名代表的是整个数组的地址，除此之外，其他地方的数组名都是首元素的地址。

# 数组里面的相关运算：

arr+1表示指向的地址跳过一个元素类型的大小（比如数组arr[]里面都是int型的元素，那么加几就跳过几个int的大小，并指向跳完之后的地址）；如是&arr加1那就是跳过整个数组大小的距离；

# 一维数组传参本质说明：

#include<stdio.h>
void test(int arr[])
{
int sz2=sizeof(arr)/sizeof(arr[0]);
printf("sz2=%d\n",sz2);
}
int main()
{
int arr[10]={1,2,3,4,5,6,7,8,9,10};
int sz1=sizeof(arr)/sizeof(arr[0]);
printf("sz1=%d\n",sz1);
test(arr);
return 0;
}

我们发现在函数内部是没有正确获得数组的元素个数。

这就要学习数组传参的本质了，上个⼩节我们学习了：数组名是数组⾸元素的地址；那么在数组传参

的时候，传递的是数组名，也就是说本质上数组传参本质上传递的是数组⾸元素的地址。

所以函数形参的部分理论上应该使⽤指针变量来接收⾸元素的地址。那么在函数内部我们写

sizeof(arr) 计算的是⼀个地址的⼤⼩（单位字节）⽽不是数组的⼤⼩（单位字节）。正是因为函

数的参数部分是本质是指针，所以在函数内部是没办法求的数组元素个数的。

void test(int arr[])//参数写成数组形式，本质上还是指针
{
 printf("%d\n", sizeof(arr));
}
void test(int* arr)//参数写成指针形式
{
 printf("%d\n", sizeof(arr));//计算⼀个指针变量的⼤⼩
}
int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,10};
 test(arr);
 return 0;
}

数组传参形参部分可以写成数组形式，也可以写成指针形式。

# 二级指针

一级指针也有地址，二级指针指向的就是一级指针的地址，对二级指针类型的变量解引用的到的就是一级指针的地址；

## 指针数组和数组指针：

指针数组是存放指针变量的数组；

int a=0;
int b=1;
int c=2;
int* p1=&a;
int* p2=&b;
int* p3=&c;

int *p[3]={p1,p2,p3};

数组指针是指向一个数组地址的指针；

int arr[]={1,2,3,4,5};
int(*p)[]=&arr;

注意到，加括号的区别，这是因为[]的结合性比*的高，想要它是一个指针数组类型那就不需要加括号，p先和[]结合，那么从一开始就确定了p的类型是一个数组，里面存放的是int*型的一个一个指针变量，构成一个指针数组；想要它是一个数组指针，那么我们要用括号把*和p括在一起，这样就可以先保证它是一个指针，指向的就是一个数组的地址；

# 了解相关知识后可以发现：假设有一个数组 int arr[]={1,2,3};

那么arr代表它首元素的地址；&arr[0]也是首元素的地址，*arr和arr[0]相应地就是第一个元素，那么*(arr+1)和arr[1]就是第二个元素，此时我们定义一个指针变量指向int* p=arr,本质上我们在使用p的时候也可以跳出指针的写法局限，这样写p[0],这和*p是一样的，同样的p[1]和*(p+1)也是一样的，这是和arr一样的模式。