目录
1. 指针是什么？
指针是什么？
指针理解的2个要点：
1. 指针是内存中一个最小单元的编号，也就是地址
2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量
总结：指针就是地址，口语中说的指针通常指的是指针变量。
那我们就可以这样理解：
内存
指针变量
我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量
//计算机支持
//32位虚拟地址空间
//CPU——32位地址——地址线传输——>内存 ——32bit——4byte
//64位虚拟地址空间
//CPU——64位地址——地址线传输——>内存 ——64bit——8byte
//1.指针变量
int main()
{
int a = 10;//a 在内存中创建四个字节的空间——占4个小单元
int* pa = &a;// 取出得是 a 的首地址,放进指针变量 pa 里面
//pa是一个变量，专门用来存放地址的
//32位地址中，pa创建四个字节的空间用于存放地址
//地址就是为了能快速的定位到内存中的某个单元
return 0;
}总结：
指针变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。
那这里的问题是：
一个小的单元到底是多大？（1个字节）
如何编址？
对于我们现在的计算机来说，计算机编制方式主要都是采用按字节编址的方式。 所以我们可以把内存简单的看成一个线性数组，数组每个元素的大小为8bit，我们称为一个存储单元，对这些存储单元我们从0x00000000开始沿着Rank的访问编址，每8个Cell加1，这样数组里的每个元素都由地址，超过一个Rank的，从上一个Rank的最后一个Cell的地址加1作为基地址。
对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压）就是（1或者0）；
那么32根地址线产生的地址就会是：
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000001
...
11111111 11111111 11111111 11111111
这里就有2的32次方个地址。
每个地址标识一个字节，那我们就可以给（2^32Byte == 2^32/1024KB == 2^32/1024/1024MB==2^32/1024/1024/1024GB == 4GB）4G的空闲进行编址。
同样的方法，那64位机器，如果给64根地址线，那能编址多大空间，自己计算。
这里我们就明白：
在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。
那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。
总结：
指针是用来存放地址的，地址是唯一标示一块地址空间的。
指针的大小在32位平台是4个字节，在64位平台是8个字节。
指针的所占空间的大小取决与地址线的多少
每根地址线所产生高低电平的多少，决定了指针变量的所占空间大小
2. 指针和指针类型
这里我们在讨论一下：指针的类型
我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？
准确的说：有的。
当有这样的代码：
int num = 10;
p = #
要将&num（num的地址）保存到p中，我们知道p就是一个指针变量，那它的类型是怎样的呢？
我们给指针变量相应的类型。
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 类型变量的地址。
那指针类型的意义是什么？
//指针类型的作用
int main()
{
//int a = 10;
//int* pa = &a;
//char ch = 'e';
//char* pb = &ch;
//printf("%d\n", sizeof pa);//4
//printf("%d\n", sizeof pb);//4
这里指针变量存放的是地址，把不管你是什么类型，地址大小只能为4 / 8 Byte
//指针类型的作用
int a = 0x11223344;//存储16进制的数值
//int* pa = &a;
//*pa = 0; // 这里改变了整型a所存储的4个字节的数据
//如果改成以下
char* pa = &a; // 从空间角度讲，pa可以放的下a的地址
*pa = 0; // 这次通过解引用访问a，只改变了一个字节的数据
//小端存储模式，此时并未发生截断
//指针类型决定了指针在被解引用的时候，访问的权限；
//整形指针访问了4个字节
//字符指针访问了1个字节
//......
return 0;
}
//指针类型决定了指针在被解引用的时候，访问的权限；
//整形指针访问了4个字节
//字符指针访问了1个字节
//......
2.1 指针+-整数
int main()
{
int a = 10;
int* pa = &a;
char* pc = &a;
printf("%p\n", pa);//00AFFDBC
printf("%p\n", pc);//00AFFDBC
printf("%p\n", pa + 1);//00AFFDC0，跳了4个字节
printf("%p\n", pc + 1);//00AFFDBD，跳了1个字节
//指针类型决定了指针向前或者向后走一步，走多大距离
//int* +1 --> +1 * sizeof(int) == +4
//char* +1 --> +1 * sizeof(char) == +1
//int* +n --> +n * sizeof(int)
//char* +n --> +n * sizeof(char)
return 0;
}总结：
指针的类型决定了指针向前或者向后走一步有多大（距离）。
2.2 指针的解引用
int main()
//{
// int arr[10] = {0};
//
// 如果希望按照一个整型的形式去访问
// //int* p = arr;
// //int i = 0;
// //for (i = 0; i < 10; i++)
// //{
// // *p = 0x11223344;
// // p++;
// //}
//
// 假设你希望，你访问这40个字节，是以字节为单位；
// //char* p =(char*) arr;//int *
// //int i = 0;
// //for (i = 0; i < 40; i++)
// //{
// // *p = 'x';
// // p++;
// //}
//
// return 0;
//}总结：
指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。
比如：char*的指针解引用就只能访问一个字节，而int*的指针的解引用就能访问四个字节。
3. 野指针
概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
3.1 野指针成因
1. 指针未初始化
int main()
{
//int* p = NULL;//空指针
int* p;//未初始化，随机值————野指针
*p = 20;
return 0;
}2. 指针越界访问
int main()
{
int arr[5] = { 1,2,3,4,5 };
int i = 0;
int* p = arr;
for (i = 0; i < 10; i++)
{
//当指针指向的范围超出数组arr的范围时，p就是野指针
printf("%d ", *p);
p++;
}
return 0;
}3. 指针指向的空间释放
这里放在动态内存开辟的时候讲解，这里可以简单提示一下。
int* test()
{
int a = 10;
//局部变量a创建，在内存中开辟空间，就会拥有地址
//假设为 0x 00 12 ff 44
printf("%d\n", a);
//打印a
return &a;
}
//a这个变量进局部范围创建，出局部范围就会销毁
//a已经销毁，指针变量还记着这个内存地址，形成非法访问
int mian()
{
int *p=test(); //0x 00 12 ff 44
//这里的p就相当于野指针
*p = 100;
return 0;
}3.2 如何规避野指针
1. 指针初始化
int main()
{
int a = 10;
int* p = &a;
int* q = NULL;
if (q != NULL)
{
}
p = NULL;
return 0;
}2. 小心指针越界
3. 指针指向空间释放即时把它置为NULL
4. 避免返回局部变量的地址
5. 指针使用之前检查有效性
4. 指针运算
指针+- 整数
指针-指针
指针的关系运算
4.1 指针+-整数
#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
*vp++ = 0;
}
4.2 指针-指针
//int main()
//{
// int arr[10] = { 0 };
// printf("%p\n", &arr[9] - &arr[0]);//9
// //指针-指针的前提，两个指针必须指向同一块空间
// //指针-指针的绝对值，得到的是指针和指针之间元素的个数
// return 0;
//}
//my_strlen
//1.计数器方法
//2.递归方法
//3.指针-指针
//int my_strlen(char* str)
//{
// char* pc = str;
// while (*str != '\0')
// {
// str++;
// }
// return str - pc ;
//}
//int main()
//{
// char arr[] = "abcdef";
// int len = my_strlen(arr);
// printf("%d\n", len);//6
// return 0;
//}4.3 指针的关系运算
for( vp = &values [N_VALUES] ; vp > &values [ 0 ] ;)
{
*--vp = 0;
}
代码简化，这将代码修改如下：
for( vp = &values [N_VALUES - 1] ; vp >= &values [ 0 ] ; vp-- )
{
*vp = 0;
}
实际在绝大部分编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证他可行。
标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。
5. 指针和数组
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
for (i = 0; i < sz; i++)
{
printf("%d ", * (p+i));
}
//printf("%p\n", arr);
//printf("%p\n", &arr);
数组就是首元素地址
但是有两个例外
1.sizeof（数组名）这里数组名表示整个数组，计算的是整个数组的大小
2.&arr，数组名表示整个数组，取出的是整个数组的地址
//printf("%d\n", sizeof(arr));
return 0;
}// 数组和指针不是一回事
//
// 数组是一块连续的空间
// 指针是存放地址的变量
//
// 可以通过指针访问数组
可见数组名和数组首元素的地址是一样的。
结论：数组名表示的是数组首元素的地址。（2种情况除外，数组章节讲解了）
那么这样写代码是可行的：
int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int *p = arr;//p存放的是数组首元素的地址
既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问一个就成为可能。
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("%p\n", arr); //00AFF994
printf("%p\n", arr+1); //00AFF998
//这里地址增加了4
printf("%p\n", &arr[0]); //00AFF994
printf("%p\n", &arr[0]+1);//00AFF998
//这里地址增加了4
printf("%p\n", &arr); //00AFF994
printf("%p\n", &arr+1); //00AFF9BC 增加16进制的28
//这里地址增加了40
return 0;
}6. 二级指针
指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？这就是二级指针。
对于二级指针的运算有：
*ppa通过对ppa中的地址进行解引用，这样找到的是pa，*ppa其实访问的就是pa.
**ppa先通过*ppa找到pa,然后对pa进行解引用操作：*pa，那找到的是a.
int main()
{
int a = 10;
int* pa = &a;//pa是指针变量（一级指针）
int** ppa = &pa;//ppa（是一个二级指针）
int*** pppa = &ppa;//三级指针
//*ppa ---> pa
//*pa ---> a
//* *ppa ---> a
**ppa = 20;
printf("%d\n", a);
***pppa = 50;
printf("%d\n", a);
return 0;
}
7. 指针数组
指针数组是指针还是数组？
答案：是数组。是存放指针的数组。
数组我们已经知道整形数组，字符数组。
//7.指针数组---存放指针的数组
//整型数组
//int main()
//{
// int arr[5];//存放整形的数组
// char ch[6];//存放字符的数组
//
// int a = 10;
// int b = 11;
// int c = 12;
// int d = 13;
// int e = 14;
// int* arr2[5] = { &a,&b,&c,&d,&e };//指针数组
// int i = 0;
// int sz = sizeof(arr2) / sizeof(arr2[0]);
// for (i = 0; i < sz; i++)
// {
// printf("%d ", *(arr2[i]));
// }
// return 0;
//}
int main()
{
int data1[] = { 1,2,3,4,5 };
int data2[] = { 2,3,4,5,6 };
int data3[] = { 3,4,5,6,7 };
int* arr[3] = { data1,data2,data3 };
//指针数组
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
//printf("%d", *(arr[i] + j));
printf("%d ", arr[i][j]);
}
printf("\n");
}
return 0;
}
167
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
