文章目录
- 1.指针是什么
- 2.指针和指针类型
- 2.1 指针的解引用
- 2.2 指针+ -整数
- 3.野指针
- 3.1 野指针成因
- 3.2 如何规避野指针
- 4. 指针运算
- 4.1 指针+-整数
- 4.2 指针-指针
- 4.3 指针的关系运算
- 5. 指针和数组
- 6. 二级指针
- 7. 指针数组
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根地址线产生的地址就会是：
这里我们就明白：
- 在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。
- 那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。
总结：
- 指针变量是用来存放地址的，地址是唯一标示一个内存单元的
- 指针的大小在32位平台是4个字节，在64位平台是8个字节
2.指针和指针类型
char *pc = NULL;
int *pi = NULL;
short *ps = NULL;
long *pl = NULL;
float *pf = NULL;
double *pd = NULL;
指针的定义方式是： type + * 。
char* 类型的指针是为了存放 char 类型变量的地址。
short* 类型的指针是为了存放 short 类型变量的地址。
int* 类型的指针是为了存放 int 类型变量的地址。
2.1 指针的解引用
代码演示
#include <stdio.h>
int main()
{
int n = 0x11223344;
char* pc = (char*)&n;
int* pi = &n;
*pc = 0; //重点在调试的过程中观察内存的变化。
*pi = 0; //重点在调试的过程中观察内存的变化。
return 0;
}
总结：
指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。
比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。
2.2 指针+ -整数
代码演示
#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;
}
运行结果：
总结： 指针的类型决定了指针向前或者向后走一步有多大（距离）。
3.野指针
概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
3.1 野指针成因
- 指针未初始化
#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;
}
- 指针指向的空间释放
#include <stdio.h>
int* test()
{
int a = 10;
return &a;
}
int main()
{
int*p = test();
*p = 100;
return 0;
}
a出test函数就已经销毁，但是return把a的地址传给了p，
p里边存放了a的地址，但是p不能在对其进行修改
3.2 如何规避野指针
- 指针初始化
- 小心指针越界
- 指针指向空间释放，及时置NULL
- 避免返回局部变量的地址
- 指针使用之前检查有效性
#include <stdio.h>
int main()
{
//一个指针不知道应该指向哪里的时候，暂时可以初始化为NULL;
int* p = NULL;
if (p != NULL)//判断指针是否为空，不为空再进行访问
{
*p = 100;
}
return 0;
}
4. 指针运算
4.1 指针±整数
代码演示：
#include <stdio.h>
int my_strlen(char * str)
{
int count = 0;
while (*str != '\0')
{
count++;
//指针+整数
str = str + 1;
}
return count;
}
int main()
{
int len = my_strlen("abcdef");
printf("%d\n", len);
return 0;
}
运行结果
4.2 指针-指针
指针-指针=地址-地址
代码演示：
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int n = &arr[9] - &arr[0];
printf("%d\n", n);
return 0;
}
运行结果：
总结： 指针加整数等于指针，指针减指针等于整数
4.3 指针的关系运算
//代码一
#define N_VALUES 5
float values[N_VALUES];
float* vp;
//指针关系的运算
for (vp = &values[N_VALUES]; vp > &values[0];)
{
*--vp = 0;
}
通过- -vp把values数组改成0
代码简化
//代码二：
for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
*vp = 0;
}
让vp指向下标为4的元素，通过- -vp把values数组改成0
代码二实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证
它可行。
标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与
指向第一个元素之前的那个内存位置的指针进行比较。
允许p1与p3进行比较，不允许p1与p2进行比较
5. 指针和数组
指针就是指针，不是数组
数组就是数组，也不是指针
指针和数组的关系：
指针是可以指向数组元素的
因为指针可以运算，所以借助指针可以访问数组
代码演示：
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
int* p = arr;//指针存放数组首元素的地址
int i = 0;
//存放
for (i = 0; i < 10; i++)
{
*p = i + 1;
p++;
}
//打印
p = arr;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
return 0;
}
运行结果：
6. 二级指针
指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？
这就是 二级指针 。
代码演示：
#include <stdio.h>
int main()
{
int a = 10;//a是要在内存中申请4个字节的空间的
//一级指针
int* pa = &a;//0x0012ff40, pa是指针变量，用来存放地址，也得向内存申请，申请4/8
//二级指针
int** ppa = &pa;//0x0012ff48
printf("%d\n", **ppa);
return 0;
}
运行结果：
二级指针的运算
- *ppa 通过对ppa中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa。
int b = 20;
*ppa = &b;//等价于 pa = &b;
- **ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 a。
**ppa = 30;
//等价于*pa = 30;
//等价于a = 30;
7. 指针数组
指针数组是指针还是数组？
答案：是数组。是存放指针的数组。
代码演示：
#include <stdio.h>
int main()
{
int a = 10;
int b = 20;
int c = 30;
int* arr[] = { &a,&b,&c };
int i = 0;
for (i = 0; i < 3; i++)
{
printf("%d ", *(arr[i]));
}
return 0;
}
运行结果：
指针数组与二级指针的结合
#include <stdio.h>
int main()
{
char* arr[5];//[char* char* char* char* char*]
char** p = arr;//&arr[0] - char**
return 0;
}
用一维数组模拟出一个二维数组
看代码：
#include <stdio.h>
int main()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 2,3,4,5,6 };
int arr3[] = { 3,4,5,6,7 };
int* ptr[] = { arr1,arr2,arr3 };
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j< 5; j++)
{
printf("%d ",ptr[i][j]);
}
printf("\n");
}
return 0;
}
运行结果：
