1. 指针是什么2. 指针和指针类型3. 野指针4. 指针运算5. 指针和数组6. 二级指针7. 指针数组
目录
1. 指针是什么?
2. 指针和指针类型
2.1 指针+-整数
2.2 指针的解引用
3. 野指针
3.1 野指针成因
3.2 如何规避野指针
4. 指针运算
4.1 指针+-整数
4.2 指针-指针
5. 指针和数组
6. 二级指针
7. 指针数组
#include
int main()
{
int a = 10;//a占4个字节 - (32位)
int* pa = &a;//拿到的是a的4个字节中第一个字节的地址
*pa = 20;
return 0;
}
#include
int main()
{
int a = 10;//在内存中开辟一块空间
int *p = &a;//这里我们对变量a,取出它的地址,可以使用&操作符。
//a变量占用4个字节的空间,这里是将a的4个字节的第一个字节的地址存放在p变量
中,p就是一个之指针变量。
return 0;
}
00000000 00000000 00000000 0000000000000000 00000000 00000000 00000001...11111111 11111111 11111111 11111111
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 + * 。
指针类型决定了:指针走一步,能走多远(步长)指针分别+1(向前走) int+4 、char+1、double+8
//指针类型的意义
// 1.指针类型决定了:指针解引用的权限有多大
// 2.指针类型决定了:指针走一步,能走多远(步长)指针分别+1(向前走) int+4 、char+1、double+8
int main()
{
int arr[10] = { 0 };
int* p = arr;
char* pc = arr;
printf("%p\n", p);
printf("%p\n", p+1);
printf("%p\n", pc);
printf("%p\n", pc + 1);
//十六进制0 1 2 3 4 5 6 7 8 9 a b c d e f
//四个二进制位可表示一个十六进制位
//int a = 0x11223344;
/*char* pc = &a;
*pc = 0;*/
/*int* pa = &a;
*pa = 0;*/
return 0;
}
#include
//演示实例
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;
}
int main()
{
int arr[10] = { 0 };
/*int* p = arr;*/
char* pc = arr;
int i = 0;
for (i = 0; i < 10; i++)
{
//*(p + i)=1; //其实是下标为i的地址 数组赋值1 走一步跳过一个整型,解引用访问的也是一个整型
*(pc + i) = 1;//一个字节跳过一个字节的访问,一个字节一个字节的操作,当做char来访问
}
return 0;
}
整型指针加1跳过一个整型,字符指针加1跳过一个字符。
//演示实例
#include
int main()
{
int n = 0x11223344;
char *pc = (char *)&n;
int *pi = &n;
*pc = 0; //重点在调试的过程中观察内存的变化。
*pi = 0; //重点在调试的过程中观察内存的变化。
return 0;
}
总结:
#include int main (){int * p ; // 局部变量指针未初始化,默认为随机值* p = 20 ;return 0 ;}
#include int main (){int arr [ 10 ] = { 0 };int * p = arr ;int i = 0 ;for ( i = 0 ; i <= 11 ; i ++ ){// 当指针指向的范围超出数组 arr 的范围时, p 就是野指针* ( p ++ ) = i ;}return 0 ;}
&a 返回给主函数后,空间释放;进入test函数时a创建,出这个函数时a销毁了,也就是说return 返回a的地址时,a的生命周期已经结束了,a占4个字节的地址还给了系统。能放但是这块空间已经不是你的程序创建声明的空间了。野指针相当于你去开一间房子,当房子到期了,你记住了房号,你是可以非法入住的。
#include int main (){int * p = NULL ;//....int a = 10 ;p = & a ;if ( p != NULL ){* p = 20 ;}return 0 ;}
因为NULL是0,0地址空间是不属于用户的 。应该先给p=&a,再解引用。
#include
int main()
{
//当不知道p应该初始化为什么地址的时候,直接初始化为NULL
//int* p = NULL;
//明确知道初始化的值
/*int a=10;
int* ptr = &a;*/
//C语言本身不会检查数据的越界行为的
int* p = NULL; //一个指针变量当你不知道它指向什么地方时,你让它置为空指针
//当它指向的空间被释放了后,你也把它置为空指针,所以当它指向有效空间时就给他个有效地址,这样指针要是空指针,要么是指向有效空间
if(p!=NULL)
*p = 10;
return 0;
}
#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数;指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
*vp++ = 0;
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;//让p指向数组首元素
int* pend = arr + 9;//指向第10个元素
while (p <= pend)
{
printf("%d\n", *p);//解引用 相当于变量 1 2 3 4 5 6 7 8 9 10
p++;
}
return 0;
}
int my_strlen(char *s)
{
char *p = s;
while(*p != '\0' )
p++;
return p-s;
}
指针-指针得到的两个指针之间的元素个数
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
char c [5];
//指针与指针相减的前提:两个指针指向同一块空间
printf("%d\n", &arr[9] - &c[0]);//?
// 指针-指针得到的两个指针之间的元素个数
printf("%d\n", &arr[9] - &arr[0]); //9
return 0;
}
#include
//计数器方法:
//int my_strlen(char* str)
//{
// int count = 0;
// while (*str!='\0')
// {
// count++;
// str++;
// }
// return count;
//}
int my_strlen(char* str)
{
char* start = str;
while (*str != '\0');
{
str++;
}
return str - start;
}
int main()
{
//strlen(); - 求字符串长度
// int len = strlen("abc");
//printf("%d\n", len);
//
//递归
int len = my_strlen("abc");//传递过去的是首个字符a的地址 相当于 char arr[]="abc";相当于传arr
printf("%d\n", len);
return 0;
}
#include
int my_strlen(char* str) //str是个指针,str指向数组arr的首原地址也就是b
{
if (*str != '\0') //* str 解引用拿到的是 b i t,如果是str 那么拿到的是个地址
return 1 + my_strlen(str + 1);
else
return 0;
}
int main()
{
char arr[] = "bit";
//['b']['i']['t']['\0'] \0是字符串的结束标志,我们在计算字符串时不计算它
//模拟实现一个strlen函数
printf("%d\n", my_strlen(arr));//数组名arr相当于首元素的地址-也就是字符b的地址,所以写成char* str
return 0;
}
for ( vp = & values [ N_VALUES ]; vp > & values [ 0 ];){*-- vp = 0 ;}
for ( vp = & values [ N_VALUES - 1 ]; vp >= & values [ 0 ]; vp -- ){* vp = 0 ;}
#include
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 存放的是数组首元素的地址
#include
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 p+%d = %p\n", i, &arr[i], i, p+i);
}
return 0;
}
运行结果:
所以 p+i 其实计算的是数组 arr 下标为i的地址。
int main()
{
int arr[10] = { 0 };
int* p = arr;
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%p <==> %p\n", &arr[i], p + i);
*(p + i) = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
//printf("%p\n", arr);//数组名是数组首元素的地址
//printf("%p\n", &arr[0]);
return 0;
}
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
int mian()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;//数组名
//[] 是一个操作符 2和arr是两个操作数
//a+b
//b+a
//arr[2]-->*(arr+2)-->*(2+arr)-->2[arr]
printf("%d\n", 2[arr]);
printf("%d\n", arr[2]);//p[2]-->*(p+2)
//arr[2]<==>*(arr+2)<==>*(p+2)<==>*(2+p)<==>*(2+arr)==2[arr]
//2[arr]<==>*(2+arr)
return 0;
}
int main()
{
int a = 10;
int* pa = &a;//pa是指针变量,一级指针
//ppa就是一个二级指针变量
int* *ppa=&pa;//pa也是个变量 ,&pa取出pa在内存中的起始地址 *paa 是指针,int * *ppa 告诉我指向pa
//pppa就是一个三级指针变量
int*** pppa = &ppa;
return 0;
}
// *ppa==pa
//*pa==a
//**ppa==a
对于二级指针的运算有:
int b = 20 ;* ppa = & b ; // 等价于 pa = &b;
** ppa = 30 ;// 等价于 *pa = 30;// 等价于 a = 30;
int arr1 [ 5 ];char arr2 [ 6 ];
那指针数组是怎样的?
int* arr3 [ 5 ]; // 是什么?
int main()
{
int arr[10];//整形数组 - 存放整形的数组就是整形数组
char ch[5];//字符数组 - 存放的是字符
//指针数组 - 存放指针的数组
int *parr[5];//存放整形指针的数组
char* pch[5];//存放字符指针的数组
return 0;
}