指针及其应用

1、变量的访问有两种方式：
（1）变量名直接访问
（2）地址直接访问（*代表取地址里面的内容）
代码如下：

#include<stdio.h>
int main()
{
	int a=99;
	int b=999;
	printf("通过变量名访问内容，a的值是：%d\n",a);
	printf("通过变量名访问内容，b的值是：%d\n",b);
	printf("通过地址访问内容，a的值是：%d\n",*(&a));
	printf("通过地址访问内容，b的值是：%d\n",*(&b));
	return 0;
}

运行结果是：

2、下面我们来验证一下数组地址的连续性。
int a=10;//整形变量存放的是整数
char c=‘Q’;//字符变量存放的是字符
int array[2]={2,4};//数组变量，存放的是同一类型的数据
int* p=&a;//整型指针变量，p是变量名用于指向a的地址，这个指针只能指向整形变量
int *p;
p=&a;//这种写法也可以
！！！！！*只有在定义指针变量时才是指针标识符，其余任何情况均代表取地址里面的内容。
！！！

#include<stdio.h>
int main()
{
	int a;
	char b;
	printf("a的地址是%p\n",a);//这里取地址直接用元素名取地址
	printf("b的地址是%p\n",b);
	printf("++a的地址是%p\n",++a);//偏移了四个字节
	printf("++b的地址是%p\n",++b);//偏移了1个字节
	
	int i;
	int array[3]={1,3,5};
	int* parry;
	parry=array;
	for(i=0;i<3;i++)
	{
		printf("地址是%p\n",parry++);
	}
	parry=array;//此事指针已经越界，需要重新指向数组头地址
	for(i=0;i<3;i++)
	{
		printf("地址是%d\n",*(parry++));
	}
	parry=array;
	return 0;
}

下面利用指针，数组，函数三者结合重新编写成绩统计。

#include<stdio.h>
void get_array(int* array,int cnt)//array[]传输过来的是首地址
{								//形式参数中，虽然写的是数组的样子，但是大括号中数组的大小是无效的！！！
								//不管括号中数字是多大都不能代表数组的大小，数组的大小要依靠主函数中的sizeof来计算
								//中括号仅仅用来表示该参数是一个地址（后续的指针），在windows中，用4个字节（1字节等于8bit，也就是32位）
								//来表示，在linux下，地址（指针）用8个字节来表示。
	int i;
	for(i=0;i<cnt;i++)
	{	
	printf("请输入数组中第%d个元素：\n",i+1);
	scanf("%d",array);
	array++;
	}
	array=&(array[0]);
}
void print_array(int* array,int cnt)//直接把数组首地址传输过去，此刻这是指向数组首地址的指针而不是数组
{
	int i;
	for(i=0;i<cnt;i++)
	{	
	printf("数组中第%d个元素值是%d：\n",i+1,array);
	array++;//每次指针指完之后都要进行偏移
	}
	array=&array[0];//每次偏移完成以后都要重新指向数组头
}
void array_max(int* array,int cnt)
{
	int i;
	int max=array[0];
	for(i=0;i<cnt;i++)
	{
		if(max>*array)
		{
			max=*array;
		}
		array++;
	}
	printf("**********************\n");
	printf("该数组中最大值是：%d\n",max);
	array=&array[0];
}
void array_min(int* array,int cnt)
{
	int i;
	int min=array[0];
	for(i=0;i<cnt;i++)
	{
		if(min<*array)
		{
			min=*array;
		}
		array++;
	}
	printf("**********************\n");
	printf("该数组中最小值是：%d\n",min);
	array=&array[0];
}
void array_average(int* array,int cnt)
{
	int i;
	int sum=0;
	float average;
	for(i=0;i<cnt;i++)
	{
		sum=sum+(*array);
		array++;
	}
	average=(float)sum/cnt;
	printf("**********************\n");
	printf("该数组中所有元素平均值是：%f\n",average);
	array=&array[0];
}
int main()
{
	int array[8];
	int *p=array;
	int cnt;//cnt代表着数组的元素个数
	cnt=sizeof(array)/sizeof(array[0]);
	get_array(p,cnt);//传输的是地址过去，从键盘输入以后，相当于已经改变了数组的值，接下来直接就可以使用
	print_array(p,cnt);
	array_max(p,cnt);
	array_min(p,cnt);
	array_average(p,cnt);
	return 0;
}

！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
强制让指针指向固定的地址：

#include<stdio.h>
int main()
{

	int* p;
	p=(int*)0x0040002;//强制把这个地址转换为一个整型数的地址，让p指针指向这个地址
	printf("p转换后的地址是%p\n",p);
	return 0;
}

这个应用体现了指针的厉害之处。
volatile用于编译器的优化，后续进行详细的了解。
3、当直接用变量中间值来交换两个数的大小时是可以的，但用函数封装后，因为是形式参数所以必须使用指针对两个变量进行操作。下面我们来验证一下用函数封装一个交换函数，看下最终会不会对其值进行改变。

#include<stdio.h>
void add1(int a1)
{
	a1=a1+1;//运行时，此刻程序里面有两个地址存10
}
void add2(int* a2)
{
	*a2=*a2+1;//此刻，内存里只有一个地址存10
}
int main()
{
	int a1=10;
	int a2=10;
	add1(a1);
	add2(&a2);//指针传输的是地址
	printf("a1的值是%d\n",a1);
	printf("a2的值是%d\n",a2);
	return 0;
}

这里我们来分析一下，这俩函数封装后同样是对一个数进行加一，为何最终输出结果截然不同。首先add1函数里面的参数是形式参数，这里的变量a在用到时才申请内存空间，用完后随即释放。add2函数里面的变量时指针，用于存放地址，里面改变的是变量地址里面的内容，所以在main函数里面最终只有对指针进行操作才能改变变量的最终值。当进行两数交换时也是同样的道理。
4、指针数组，又叫多个指针的组，多个指针存放到一个组里面，形成了指针的集合。

#include<stdio.h>
int main()
{
	int* array[3];
	int a=3;
	int b=33;
	int c=333;
	array[0]=&a;
	array[1]=&b;
	array[2]=&c;
	int i;
	for(i=0;i<3;i++)
	{
		printf("指针的集合：%d\n",*array[i]);
	}
	return 0;
}

这里我们定义了一个数组，分别用于存放a,b,c的地址，便是指针数组，里面的每一项都是整型数的指针。
4、数组指针。

#include<stdio.h>
int main()
{
	/*int* p;
	int a[3];
	p=a;//此指针并非是数组指针，只是恰好指向了数组首地址的指针
	*/
	
	int a[3]={1,2,3};
	int (*p)[3];//数组指针，指向另一个数组头
	p=&a;//取数组的首地址赋值给数组指针
	printf("偏移之前指针指向的地址是%p\n",p++);
	printf("偏移之后指针指向的地址是%p\n",p);//数组指针偏移一次偏移得是整个数组的大小，即3*4=12字节
	return 0;
}

！！！数组指针偏移一次偏移得是整个数组的大小。
5、函数指针。

#include<stdio.h>
void print_welcome()
{
	printf("欢迎来到南京邮电大学\n");
}
int main()
{
	void (*p2)();//定义函数指针（牢记函数指针命名规则）
				//1.如何表示指针：*2.如何知道是函数：（）3.函数指针是专用的，格式要求很强
				//如何通过函数指针调用函数
				//p2()
				//(*p2)()
	p2=print_welcome;//给函数指针赋值，函数名相当于地址，地址赋值给指针
	p2();
	return 0;
}

6、malloc给指针开辟地址
用malloc给指针开辟固定的空间用于当做数组。

#include<stdio.h>
#include <stdlib.h>
int main()//malloc开辟数组的写法
{
	int i;
	int* parry=(int*)malloc(3*sizeof(int));
	for(i=0;i<3;i++)
	{
		printf("请输入第%d个数组元素：\n",i+1);
		scanf("%d",&parry[i]);//把输入放到元素地址里面
	}
	for(i=0;i<3;i++)
	{
		printf("第%d个数组元素是：%d\n",i+1,parry[i]);//*表示取数组指针里面的内容
	}
	return 0;
}

分析代码及最终程序运行结果可得，我们给parry开辟了12字节的空间，用于存放三个整型数，我们无须说明parry是个数组，而是在开辟空间时，系统已经默认这种写法是个数组。
用malloc开辟内存空间一定要注意避免内存泄漏。

避免内存泄露

1.程序刚跑起来，很好，跑几个小时，或者几天，程序崩溃
while(1)
{
	sleep(1);
	int* p=malloc(1024);//malloc申请的空间，程序中不会主动释放，linux中，程序结束后，系统会主动回收这个空间。
	避免：
	1.注意，循环中有没有一直申请
	2.及时合理的释放 free(p);p=NULL;这里释放后，p相当于野指针在乱指，所以让p变为NULL指针。
}