前言
想必大多数人在接触指针之前,都觉得指针比较困难,但接触之后也没有想象中的那么难,所以我们不要把问题给想复杂了。
指针就是地址,我可以通过指针变量存放的地址找到相应的元素
比如:我们想找到小明,我们是不是通过地址找更容易,更快一些。
创作不易,留下你的小心心再走吧
1.指针是什么
指针理解的2个要点:
1.指针是内存中一个最小单元的编号,也就是地址
2. 平时口语中说的指针,通常指的是指针变量,是用来存放内存地址的变量
总结:指针就是地址,口语中说的指针通常指的是指针变量
在内存中,每个字节都有自己的单元编号
指针变量
我们可以通过&(取地址操作符)取出变量的内存起始地址,把地址可以存放到一个变量中,这个变量就是指针变量
#include <stdio.h>
int main()
{
int a = 10;//在内存中开辟一块空间
int *p = &a;//这里我们对变量a,取出它的地址,可以使用&操作符。
//a变量占用4个字节的空间,这里是将a的4个字节的第一个字节的地址存放在p变量中,p就是一个之指针变量。
return 0;
}
指针变量,用来存放地址的变量。(存放在指针中的值都被当成地址处理)
对于32位的机器,假设有32根地址线,那么假设每根地址线在寻址的时候产生高电平(高电压)和低电平(低电压)就是(1或者0)
那么32根地址线产生的地址就会是:
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000001
…
11111111 11111111 11111111 11111111
这里就有2的32次方个地址
每个地址标识一个字节,那我们就可以给 (2^32Byte =2^32/1024KB =
232/1024/1024MB==232/1024/1024/1024GB =4GB) 4G的空间进行编址(64位机器则是2^64个地址)
在32位机器上,一个指针变量的大小就是4个字节
在64位机器上,一个指针大小是8个字节
2.指针和指针类型
这里我们在讨论一下:指针的类型
我们都知道,变量有不同的类型,整形,浮点型等。那指针有没有类型呢?
准确的说:有的。
char *pc = NULL;
int *pi = NULL;
short *ps = NULL;
long *pl = NULL;
float *pf = NULL;
double *pd = NULL;
32位机器为例:
既然指针都是4个字节,那指针类型存在的意义又是什么呢?
#include <stdio.h>
int main()
{
int n = 10;
char* pc = (char*)&n;
int* pi = &n;
printf("%p\n", pc);//char类型的指针
printf("%p\n", pc + 1);
printf("%p\n", pi);//int类型的指针
printf("%p\n", pi + 1);
return 0;
}
运行结果:
我们可以清楚的看到:
char类型的指针+1是跳过了1个字节的位置
int类型的指针+1是跳过了4个字节的位置
由此可见指针类型之前的区别
总结:指针的类型决定了指针向前或者向后走一步有多大(距离)
2.1指针的解引用
#include <stdio.h>
int main()
{
int n = 0x11223344;//0x是以16进制表示
char* pc = (char*)&n;//把int类型的变量地址放到char类型的指针
int* pi = &n;
*pc = 0; //重点在调试的过程中观察内存的变化。
*pi = 0;
return 0;
}
我们先看把int类型的变量地址放到char类型指针变量里,然后解引用*pc赋值0的内存变化。
我们可以清楚的看到,只改变了一个字节的内存
再看int类型指针变量赋值,改变了4个字节的内容
总结:
指针的类型决定了,对指针解引用的时候有多大的权限(能操作几个字节)
3.野指针
概念: 野指针就是指针指向的位置是不可知的(随机的、不正确的、没有明确限制的)
看代码可以更清楚的理解:
#include <stdio.h>
int main()
{
int *p;//局部变量指针未初始化,默认为随机值
*p = 20;
return 0;
}
指针越界访问:
#include <stdio.h>
int main()
{
int arr[10] = {0};
int *p = arr;
int i = 0;
for(i=0; i<=11; i++)
{
//当指针指向的范围超出数组arr的范围时,p就是野指针
*(p++) = i;
}
return 0;
}
指针指向的空间释放:
这里我们用int* p来接收Test()函数返回来的指针,我们在函数内部创建了n返回n的地址,当出了函数,函数内存就会释放,主函数里*p所指向的空间就是不可控的
int* Test()
{
int n = 10;
return &n;
}
int main()
{
int* p = Test();
printf("%d\n", *p);
return 0;
}
以上代码我们都称之为野指针,比较危险,不可控。
如何规避野指针:
1 指针初始化
2.小心指针越界
3.指针指向空间释放,及时置NULL
4.避免返回局部变量的地址
5.指针使用之前检查有效性
4.指针运算
指针±整数
把数组values[0]第一个元素地址放到vp指针变量里,此时此刻*vp指向数组第一个元素,然后赋值为0,再自增1,*vp指向数组第二个元素,以此类推,循环5次。
#define N_VALUES 5
int main()
{
float values[N_VALUES];
float *vp;
//指针+-整数;指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
*vp++ = 0;
}
}
指针-指针:
指针-指针得到的是两个指针元素之间的个数
我们用指针-指针的方法来写一个求字符串长度的函数:
int my_strlen(char* arr)
{
char* start = arr;
while (*arr != '\0');
{
arr++;
}
return arr-start;//返回两个指针之间元素的个数
}
int main()
{
char arr[] = "abcdef";
int len = my_strlen(arr);
printf("%d\n", len);
return 0;
}
指针的关系运算:
for(vp = &values[N_VALUES]; vp > &values[0];)
{
*--vp = 0;
}
我们将代码简化一下:
for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
*vp = 0;
}
标准规定:
允许向数组最后一个元素后面的那个内存位置的指针比较,但是不允许与指向第一个元素之前的那个内存位置的指针进行比较
5.指针和数组
我们知道数组名就是首元素的地址
两种情况除外:
sizeof(数组名),这里的数组名是表示整个数组,计算的是整个数组的大小,单位是字节。
&(数组名),取出的是整个数组的大小
注:
指针是指针,数组是数组,只能说它们俩之间有一定的联系
数组开辟一块空间,指针可以通过首元素地址进行一系列的访问和操作
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,0};
printf("%p\n", arr);
printf("%p\n", &arr[0]);
return 0;
}
那么这样写代码是可行的:
int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int *p = arr;//p存放的是数组首元素的地址
用指针访问数组:
这里我们用到下标引用操作符访问数组,和指针访问数组,效果是一样的
int main()
{
int arr[] = {1,2,3,4,5,6,7,8,9,0};
int *p = arr; //指针存放数组首元素的地址
int sz = sizeof(arr)/sizeof(arr[0]);
for(i=0; i<sz; i++)
{
printf("&arr[%d] = %p <====> p+%d = %p\n", i, &arr[i], i, p+i);
}
return 0;
}
运行结果:
6.二级指针
指针变量也是变量,是变量就有地址,那指针变量的地址存放在哪里?
这里就要说到二级指针了
如下:
int main()
{
int a = 10;
int* pa = &a;
int** ppa = &pa;//ppa就是二级指针变量
return 0;
}
当然,我们也可以通过解引用访问
当拿到ppa的时候,解引用就能找到pa,从而就能找到a
**ppa – *pa – a
#include <stdio.h>
int main()
{
int a = 10;
int* pa = &a;
int** ppa = &pa;
printf("%d\n", **ppa);
return 0;
}
结果打印的当然就是a里面放的值,不信可以去试试啦
7.指针数组
指针数组 – 存放指针的数组
指针数组是数组?还是指针?
答案是:是数组显而易见: char arr[5] - 存放的是字符数组
int arr[5] - 存放的是整形数组
假设我们有一组变量,那我们能不能把变量的地址存起来呢?
例如:
这里就是指针数组的概念
int main()
{
int a = 10;
int b = 20;
int c = 30;
int d = 40;
int e = 50;
int* arr[5] = { &a, &b, &c, &d, &e };
return 0;
}
上面只是一种概念,可以更直观的了解指针数组
可能会用到的应用场景:
怎么用一维数组模拟出一个三行四列的数组??
int main()
{
int a[] = { 1,2,3,4 };
int b[] = { 5,6,7,8, };
int c[] = { 8,9,10,11 };
int* arr[] = { a, b, c };
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 4; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
return 0;
}
想必看到这,大家对指针有了一定的了解吧