指针详解

目录

指针是什么

指针变量

指针类型

野指针

指针和数组

 二级指针

指针数组

 数组指针

数组指针的定义

&数组名VS数组名 

指针是什么

指针理解的2个要点：

1. 指针是内存中一个最小单元的编号，也就是地址
2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

总的来讲指针就是地址，口语上说的指针通常指得是指针变量

指针变量

我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个

变量就是指针变量

int main()
{
	int a = 10;
	int* p = &a;//使用&操作符对变量a进行取地址操作，取出变量a的地址放入p中

	return 0;
}

指针变量，就是用来存放地址的变量，指针的大小在32位平台是4个字节，在64位平台是8个字节

指针类型

这里我们在讨论一下：指针的类型
我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？
准确的说：有的

当有这样的代码：

int num = 10;
p = #

要将&num（num的地址）保存到p中，我们知道p就是一个指针变量，那它的类型是怎样的呢？
我们给指针变量相应的类型

char  *pc = NULL; //存放 char 类型变量的地址。
int  *pi = NULL;  //存放 int  类型变量的地址。
short *ps = NULL;  //存放 short 类型变量的地址。
long  *pl = NULL;  //存放 long  类型变量的地址。
float *pf = NULL;  //存放 float 类型变量的地址。
double *pd = NULL;   //存放 double 类型变量的地址。

下面我们对不同类型指针变量进行测试：

int main()
{
	int a = 10;
	int* p1 = &a;
	char b = 'a';
	char* p2 = &b;
	printf("p1 = %d  p2 = %d\n", sizeof(p1), sizeof(p2));
	return 0;
}

运行结果

 p1是int*类型，p2是char*类型，它们大小一致，总结：指针大小与指针类型无关，只要是指针变量大小就是4/8个字节

那指针类型的意义是什么? 下面我们再做一组测试

int main()
{
	int a = 10;
	int* p1 = &a;
	char b = 'a';
	char* p2 = &b;
	printf("p1 = %p  p1 + 1 = %p\n", p1,(p1 + 1));
	printf("p2 = %p  p2 + 1 = %p\n", p2,(p2 + 1));
	return 0;
}

运行结果

 可以看到，int*类型的指针进行+1后向后走了4个字节，char*类型的指针进行+1后走了1个字节

总结：指针的类型决定了指针向前或者向后走一步有多大（距离),而且不只是体现在+-操作上，对指针的解引用也是有指针的类型决定的，对指针解引用的时候有多大的权限（能操作几个字节）比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。

野指针

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

野指针成因

1. 指针未初始化

#include <stdio.h>

int main()
{

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

指针变量里为随机值， 这样一来就导致了我们无法确定这块空间有没有被其他人所使用，如果这块空间已经被其他人左占用，就会造成非法访问的问题

2. 指针越界访问

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

3. 指针指向的空间释放

#include <stdio.h>

int main()
{

	int* p = (int*)malloc(10);
    free(p);
	return 0;
}

这里进行了动态内存开辟，开辟的内存在堆区里，不会随着栈帧的销毁而一起销毁，需要我没问你进行手动释放（free），释放后该变量并没有进行置空，依旧可以通过p变量对该地址进行访问，但此时这块地址已经不属于我们了，故而会造成非法访问的问题

如何规避野指针

1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放，及时置NULL
4. 避免返回局部变量的地址
5. 指针使用之前检查有效性

指针和数组

我们看一个例子：

#include <stdio.h>

int main()
{

	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	return 0;
}

运行结果：

 可见数组名和数组首元素的地址是一样的。

结论：数组名表示的是数组首元素的地址。（2种情况除外，&arr 和sizeof(arr)

那我们就可以直接通过指针来访问数组

int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    int *p = arr; //指针存放数组首元素的地址
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    for (i = 0; i<sz; i++)
    {
        printf("%d ", *(p + i));
    }
    return 0;
}

 二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？

存放指针变量地址的变量这就是二级指针 

#include <stdio.h>

int main()
{

	int a = 10;
	int* p = &a;
	int** pp = &p;
}

 故而在对二级指针访问时，要先通过对二级指针进行解引用找到一级指针，在对一级指针进行解引用：

#include <stdio.h>

int main()
{

	int a = 10;
	int b = 20;
	int* p = &a;
	int** pp = &p;
	*pp = &b;//这里对pp做第一次解引用，其实是访问到了p，也就是说*pp 等同于p
	printf("%d\n", *p);
}

运行结果 ：

 因为*pp 等同于p，所以对*pp进行重新赋值，也就是改变了p

指针数组

指针数组是指针还是数组？
答案：是数组。是存放指针的数组。
那指针数组是怎样的？

int* arr3[5];//是什么？

arr3是一个数组，有五个元素，每个元素是一个整形指针

 数组指针

数组指针的定义

数组指针是指针？还是数组？
答案是：指针。
我们已经熟悉：
整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。
那数组指针应该是：能够指向数组的指针。

举例说明：

int *p1[10];//指针数组
int (*p2)[10];//数组指针

 int (*p2)[10]是p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。 

&数组名VS数组名 

arr 和 &arr 分别是啥？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是啥？

我们看一段代码：

#include <stdio.h>
int main()
{

	int arr[10];
	printf("arr=%p\narr+1=%p\n&arr=%p\n&arr+1=%p\n", arr, arr + 1, &arr, &arr + 1);
    return 0;
}

运行结果：

 可以看到arr和&arr的地址虽然一样都是首元素地址，但是进行+1之后，arr只向后走了4字节，而&arr却走了40 个字节，这样就可以看出，&arr其实取出的是整个数组的地址，所以在进行+1后跳过了整个数组