C语言--指针

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

在计算机科学中，指针是编程语言中的一个对象
利用地址，它的值直接指向存在电脑存储器中另一个地方的值
由于通过指针能找到所需的变量单原，可以说，地址指向该变量单元
因此，将地址形象化的称为“指针”
意思是通过它能找以它为地址的内存单元

一、指针是什么

指针是个变量，存放内存单元的地址（编号）

int main()
{
	int a = 10;
	在内存中开辟一块空间
	int* p = &a;
	对变量a，取出它的地址，使用&操作符
	将a的地址存放在p变量中，p就是一个指针变量
	return 0;
}

指针就是变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）
一个小的单元是1个字节

二、如何产生地址

1.引入库

32位
32根地址线/数据线
正电和负电
1 0
00000000000000000000000000000000
00000000000000000000000000000001
…
0111111111111111111111111111111111111
10000000000000000000000000000000
…
1111111111111111111111111111111111111
总共有2的32次方的序列编号（地址）
地址可以转换为二进制序列

一个空间是一个字节byte 32位电脑有4gb的内存
int a = 10 申请四个字节的空间 即上方表格四行
指针变量存放地址即存放二进制序列 32个比特位即4个字节
一个指针变量的大小为4个字节
指针大小在32位平台是4个字节 64位平台是8个字节 64位平台是64个比特位即8个字节

在内存中的存储是反过来的
int a = 0x11 22 33 44
在内存中是44 33 22 11，修改也是从44开始修改

三、指针类型

1.指针类型决定了指针进行解引用操作时能够访问的空间大小

int* p;    *p能够访问4个字节
char* p;    *p能够访问1个字节
double* p    *p能够访问8个字节

2.指针类型决定了指针的步长

int* p;    p+1~~>    4个字节
char* p;    p+1~~>    1个字节
double* p    p+1~~>    8个字节

int main()
{
	int a = 0x11223344;
	int* pa = &a;
	char* pc = &a;
	假设地址为0
	printf("%p\n",pa);        0
	printf("%p\n",pa+1);        4
	pa+1后地址加了4个字节
	printf("%p\n",pc);        0
	printf("%p\n",pc+1)        1
	pc+1后地址加了1个字节
	return 0;
}

3.指针类型修改变量值的差异

int main()
{
	用十六进制表示，2个数字占1个字节8个比特位
	int a = 0x11223344;
	在内存中的存储的数值44 33 22 11
	int* pa = &a;
	*pa = 0;
	*解引用操作，直接对a的数据进行修改
	int 类型的字节能够改修4个字节的内容
	00 00 00 00
	char* pa = &a;
	*pa = 0;
	char类型的字节只能够修改1个字节的内容
	当*pa = 0时，只会把44修改为00
	00 33 22 11
	return 0;
}

四、野指针

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

成因

1.指针未初始化

int main()
{
	int a;        局部变量不初始化，默认是随机值
	int* p;    局部的指针变量，就被初始化随机值
	*p = 20;
	内存中随便找一个地址，把里面的内容修改
	return 0;
}

2.指针越界访问

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

3.指针指向的空间释放

test()
{
	int a = 10;
	局部变量，除了这个函数，这个变量就不存在了
	消失的变量的内存和地址会还给操作系统
	return &a;
}
int main()
{
	int *p = test();
	p接受了这个归还给操作系统的地址
	*p = 20
	对地址内的值进行更改时就出现了问题
	return 0;
}

规避野指针

1.指针初始化

int main()
{
	int a = 10;
	int* pa = &a;        初始化
	int* p = NULL;        用来初始化指针的，给指针赋值
	指针赋值NULL，意味着没有指向一个有效的空间，不能访问使用
	NULL本质上是00
	return 0;
}

2.小心指针越界

3.空间释放后，把指针置为NULL

指针赋值NULL，意味着没有指向一个有效的空间，不能访问使用
int main()
{
	int a = 10;
	int* pa = &a;
	*pa = 20;
	pa = NULL;
	把pa指针设置为空，不再存放a的地址，
	return 0;
}

4.指针使用之前检查有效性

五、指针运算

指针+ - 整数

int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr;
	for(i =  0;i < sz;i++)
	{
		printf("%d",*p);
		p++;
	}
	return 0;
}
打印结果为1 2 3 4 5 6 7 8 9 10

指针 - 指针

1.结果为起始元素与中间元素额个数，即中间元素+1
2.在同一个类型数组空间中相减才有意义

int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	printf("%d\n",&arr[9} - &arr[0]);
	打印结果为9
	指针 - 指针得到的是中间元素的个数    起始元素和中间元素的个数    即中间元素+1
	return 0;
}

应用（计算字符串长度）

int my_strlen(char* str)
{
	char* start = str;
	char* end = str;
	while(*end != '\0')
	{
		end++;
	}
	return end - start;
}
int main()
{
	char arr[] = "bit";
	int len = my_strlen(arr);
	printf("%d\n",len);
	return 0;
}

六、指针的关系运算（比大小）

数组第一个元素之前的那个内存位置的指针不能进行比较，否则就是越界访问

代码1
#define N_VALUES 5
int main()
{
	float values[N_VALUES];
	float *vp;
	for(vp = &values[N_VALUES];vp > &values[0];)
	{
		*--vp = 0;
	}
	return 0;
}

代码2
#define N_VALUES 5
int main()
{
	float values[N_VALUES];
	float *vp;
	for(vp = &values[N_VALUES -1 ];vp >= &values[0];vp--)
	{
		*vp = 0;
	}
	return 0;
}

代码1符合标准规定
代码2不符合，指针与指向第一个元素之前的那个内存位置的指针进行比较
总结：
允许指向数组元素的指针与指向数组最后一个元素后的那个内存位置的指针比较
但是不允许与指向第一个元素之前的那个内存位置的指针进行比较
总结：第一个元素之前的那个内存位置的指针不能比较

七、各种指针

1.二、三、四…级指针

存放指针地址的指针（可套娃）

int main()
{
	int a = 10;
	int* pa = &a;
	int* 一级指针类型    pa 一级指针变量
	int** ppa = &pa;
	int** 二级指针类型    ppa二级指针变量
	第二个*说明这是个指针，
	ppa代表的是pa的地址
	*ppa代表的是*pa的地址
	**ppa代表的是对pa的地址解引用，所以是a的值
	int*** pppa = &ppa;
	int*** 三级指针类型    pppa三级指针变量
	第二三个*说明这是个指针
}

2.字符指针

指针地址与%s到 \0 才停止

int main()
{
	char arr[] = "abcdef";
	char* pc = arr;
	arr数组中首元素的地址存到pc中
	printf("%s\n",arr);
	printf("%s\n",pc);
	%s遇到结束标志\0才会停下
	return 0;
}
打印结果相同

指针不能修改常量字符串

int main()
{
	char arr[] = "abcdef";    常量字符串
	char* pc = arr;
	*pc = 'w';
	段错误，非法内存访问
	printf("%s\n",pc);
	return 0;
}
不可以修改字符，会崩溃

两个指针指向同一个字符串，两个指针相同

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abcdef";
	char* p1 = "abcdef";
	char* p2 = "abcdef";
	只创建了一个存放"abcdef"的空间
	两个指针指向同一个地方
	if(p1 == p2)
		printf("hehe");
	else
		printf("haha");
	return 0;
}
打印结果为hehe

3.数组指针

指向数组的指针，存放数组地址的指针

应用
一维数组的打印

int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int (*pa)[10] = &arr;
	int* p = &arr;
	int i = 0;
	for(i = 0;i < 10;i++)
	{
		printf("%d ",(*pa)[i]);
		printf("%d ",*(*pa+i));	*pa = arr
		printf("%d ",*(p+i));
		三种打印结果都相同
		明显第三种更简单方便
	}
	return 0;
}

int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int  i = 0;
	int*p = arr;
	for(i = 0;i < 10; i++)
	{
		ptinf("%d ",arr[i]);
		arr[i] == *(p+i) == *(arr+i) == p[i]
	}
	return 0;
}

二维数组打印

void print2(int (*p)[5],int x,int y)
{
	int i = 0;
	int j = 0;
	for(i = 0;i < x;i++)
	{
		for(j = 0;j < y;j++)
		{		
			printf("%d ",(*(*p+i))+j));
			printf("%d ",((*p+i)[j]));
			printf("%d ",p[i][j]);
			三个打印结果相同
			理清思路，一环套一环
		}
		printf("\n");
	}
	return 0;
}

int main()
{
	int arr[3][5] = {{1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7}};
	print2(arr,3,5);
	return 0;
}

int arr[5]            
arr是一个5个元素的整型数组
int* parr1[10]        
parr1是一个数组，数组有10个元素，每个元素的类型是int*，parr1是指针数组
int (*parr2)[10]        
parr2是一个指针，该指针指向一个数组，数组有10个元素，每个元素的类型是int，parr2是数组指针
int (*parr3[10])[5]    
parr3是一个数组，该数组有10个元素，每个元素是一个数组指针
该数组指针指向的数组有5个元素，每个元素是int

4.函数指针

指向函数的指针，存放函数的地址

int Add(int x,int y)
{
	return x + y;
}

int main()
{
	int (*pa)(int x,int y) = &Add;
	int (*pa)(int,int) = Add;
	两个等价，函数名即地址，&可加可不加
	int x，int y，xy可加可不加
	printf("%d\n",(*pa)(2,3));
	*pa对函数Add解引用
	return 0;
}

void Print(char*str)
{
	printf("%s\n",str);
}
int main()
{
	void (*p)(char*) = Print;
	(*p)("hellow bit");
	return 0;
}

使用(*没有用，是个摆设)

int Add(int x,int y)
{
	return x + y;
}
int main()
{
	int a = 10;
	int b = 20;
	int(*pa)(int,int) = Add;
	printf("%d\n",Add(2,3));
	printf("%d\n",pa(2,3);
	printf("%d\n",(*pa)(2,3));
	printf("%d\n",(**pa)(2,3));
	printf("%d\n",(***pa)(2,3));
	前五个都可以正常运行
	printf("%d\n",*pa(2,3));
	() 优先级高于 *    不可以运行
	return 0;
}

5.函数指针数组指针

int arr[10] = { 0 };
int (*p)[10] = &arr;
int (*pfarr[4])(int,int);    pfarr是一个数组    函数指针的数组
int (* (*ppfarr[4]) )(int,int) = &pfarr;
ppfarr 是一个数组指针，指针指向的数组有4个元素
指向的数组的每个元素的类型是一个函数指针 int(*)(int,int)
指向函数指针数组的指针

两段代码

 ( * ( void ( * ) () ) 0 )();
void(*)()        函数指针类型
(void(*)())0    强制类型转换为函数指针类型    0就是一个函数的地址
(* ( void(*)() ) 0) ();        *对0这个函数地址解引用    并调用函数    

void (*signal(int,void ( * )( int )))( int );
void(*)(int)    函数指针类型
signal(int,void(*)(Int))    函数
void(*    signal(int,void(*)(int))) (int)    函数指针类型

八、存放指针的数组

数组是存放相同类型数据的存储空间

1.指针数组

int arr[];        存放整型的数组
int* parr[4];    存放整型指针的数组
char* pch[5];    存放字符指针的数组

int main()
{    
	int a = 10;
	int b = 20;
	int c = 30;
	int d = 40;
	int* parr[4] = {&a,&b,&c,&d};
	int i = 0;
	for(i = 0;i<4;i++)
	{
		printf("%d",*(arr[i]));
	}
	打印从a到d的数
	return 0;
}

2.函数指针数组

 int (*parr1[10])()

int Add(int x,int y)
{
	return x + y;
}
int Mul(int x,int y)
{
	return x - y;
}
int Mul(int x,int y)
{
	return x * y;
}
int Div(int x,int y)
{
	return x / y;
}

int main()
{
	指针数组
	int* arr[5];
	需要一个数组，这个数组可以存放4个函数的地址    函数指针的数组
	int(*parr[4])(int,int) = {Add,Sub,Mul,Div};
	int i = 0;
	for(i = 0;i < 4;i++)
	{
	printf("%d\n",parr[i](2,3)); 
	}
	return 0;
}

九、指针与数组

1.sizeof(数组名),这里的数组名表示整个数组，计算的是整个数组的大小
只包含数组名时才代表整个数组，有符号也不行
2.&数组名，这里的数组名表示整个数组，取出的是整个数组的地址
3.除此之外所有的数组名都表示首元素地址
4.二维数组的a[0]代表第一行的数组名

1.一维数组

int main()
{
	int a[] = {1,2,3,4};
	printf("%d\n",sizeof(a));            16
	sizoeof(数组名) - 计算的是数组总大小 - 单位是字节 - 16
	printf("%d\n",sizeof(a+0));        4
	a+0不是数组名，数组名这里表示首元素地址，a+0还是首元素地址
	数组名是首元素地址
	1.sizeof(数组名) - 数组名表示整个数组
	2.&数组名 - 数组名表示整个数组

	printf("%d\n",sizeof(*a));            4
	数组名表示首元素地址，*a就是首元素

	printf("%d\n",sizeof(a+1));        4
	printf("%d\n",sizeof(a[1]));        4
	printf("%d\n",sizeof(&a));        4
	&a表示的是整个数组的地址

	printf("%d\n",sizeof(*&a));        16
	解引用整个数组的地址

	printf("%d\n",sizeof(&a+1));        4/8
	 &a+1跳过了一个数组后的地址

	printf("%d\n",sizeof(&a[0]));        4/8
	第一个元素的地址
	printf("%d\n",sizeof(&a[0]+1));    4/8
	return 0;
}    

2.二维数组

int main()
{
int a[3][4] = {0};
	printf("%d\n",sizeof(a));            48    整个数组
	printf("%d\n",sizeof(a[0][0]));        4    第一个元素
	printf("%d\n",sizeof(a[0]));        16    a[0]相当于第一行作为一维数组的数组名
sizeof(arr[0])把数组名单独放在sizeof()内，计算的是第一行的大小
	printf("%d\n",sizeof(a[0] + 1));        4    a[0] + 1不是单独将arr[0]放在sizeof内部
	所以arr[0]代表第一行	首元素地址
	首元素地址 + 1是第一行第二个元素的地址 
	printf("%d\n",sizeof(*(a[0] + 1)));    4    a[0]+1是第一行第二个元素的地址，*(a[0] +1)代表第二个元素
	printf("%d\n",sizeof(a + 1)));        4    a不是单独再sizeof里面，a是二维数组的数组名，代表首元素数组
							二维数组的首元素是第一行，第二行是第二个元素，a+1代表第二行    
	printf("%d\n",sizeof(*(a+1)));        16    解引用第二行的地址
	printf("%d\n",sizeof(&a[0] + 1)));    4    a[0]代表第一行，&a[0]取这一整行的地址    
	printf("%d\n",sizeof(*a));            16    a是首元素地址即第一行的地址，解引用第一行地址
	printf("%d\n",sizeof(a[3]));          16    第四行的数组名

3.字符数组

int main()
{
	char arr[] = {'a','b','c','d','e','f'};
	printf("%d\n",sizeof(arr));        6        sizeof计算的是数组大小
	printf("%d\n",sizeof(arr+0));        4 / 8        arr+0是首元素地址
	printf("%d\n",sizeof(*arr));        1        解引用首元素地址为元素
	printf("%d\n",sizeof(arr[1]));        1
	printf("%d\n",sizeof(&arr));        4 / 8        整个数组的地址，还是地址
	printf("%d\n",sizeof(&arr+1));        4 / 8     跳过整个数组后的地址，还是地址
	printf("%d\n",sizeof(&arr[0]+1));    4 / 8        第二个元素的地址

	strlen接受的是地址，为char*类型的指针
	printf("%d\n",strlen(arr));            随机值    数组名是首元素地址
	printf("%d\n",strlen(arr+0));        随机值    数组名首元素地址
	printf("%d\n",strlen(*arr));        随机值    第一个元素'a'，对应的ascll码值为97
	以97为地址向后延伸，非法访问内存
	printf("%d\n",strlen(arr[1]));        随机值    第二个元素'b'，对应的ascll码值为98
	以98为地址向后延伸，非法访问内存
	printf("%d\n",strlen(&arr));        随机值        
	printf("%d\n",strlen(&arr+1)        随机值-6
	printf("%d\n",strlen(&arr[0]+1));    随机值-1
	return 0;
}

4.字符串数组

int main()
{
	char arr[] = "abcdef";
	a b c d e f \0    
	printf("%d\n",sizeof(arr));        7    sizeof(arr)计算的数组的大小，单位是字节
	printf("%d\n",sizeof(arr + 0));        4 / 8    计算的是地址的大小
	printf("%d\n",sizeof(*arr));        1    *arr是首元素，sizeof(*arr)计算首元素的大小
	printf("%d\n",sizeof(arr[1]));        1    
	printf("%d\n",sizeof(&arr));        4 / 8 &arr虽然是数组的地址，但也是地址 
	printf("%d\n",sizeof(&arr + 1));    4 / 8    &arr+1是跳过整个数组后的地址，但也是地址
	printf("%d\n",sizeof(&arr[0] + 1));    4 / 8    &arr[0]+1第二个元素的地址

	printf("%d\n",strlen(arr));            6
	printf("%d\n",strlen(arr+0);        6
	printf("%d\n",strlen(*arr));        非法访问,'a'的ascll码值为97,以97为地址向后延伸，直到\0
	printf("%d\n",strlen(arr[1]));        非法访问，与上面相同
	printf("%d\n",strlen(&arr));        取得是数组的地址，数组指针 char (*p)[7]    会报警告
	printf("%d\n",strlen(&arr+1));        随机值    取得是数组的地址，数组指针 char (*p)[7]，会报警告
	printf("%d\n",strlen(&arr[0]+1));    5
	return 0;
}

5.指针与常量字符串(指针变量存放的是第一个字符的地址）

int main()
{
	char* p = "abcdef";
	a b c d e f \0
	printf("%d",sizeof(p));            4 / 8        计算指针变量p的大小
	printf("%d",sizeof(p+1));            4 / 8        得到的是字符b的地址
	printf("%d",sizeof(*p));            1        *p就是字符串的第一个字符
	printf("%d",sizeof(p[0]);            1        p[0]就是字符串的第一个字符
	printf("%d",sizeof(&p));            4 / 8        
	printf("%d",sizeof(&p + 1));        4 / 8
	printf("%d",sizeof(&p[0] + 1));     4 / 8

	printf("%d",strlen(p));            6
	printf("%d",strlen(p+1));            5
	printf("%d",strlen(*p));            非法访问,'a'的ascll码值为97，以97为地址延伸到\0停止
	printf("%d",strlen(p[0]));            非法访问
	printf("%d",strlen(&p));            随机值
	printf("%d",strlen(&p + 1));        随机值
	printf("%d",strlen((&p[0] + 1));        5
	return 0;
}