重点：
定义变量：按类型分配空间
类型 变量名；
类型 数组名；
初始化：
引用变量：引用内容
1.自身内容： 变量名； *地址
a
数组名[下标]
1、指针与变量的关系：
1.见源代码
2、指针与数组的关系：
2.1指针与一维普通数组
2.2指针数组：专门用于存放指针的数组
类型* 数组名[长度] eg： int* buf[10]
引用元素：数组名[下标法]
2.3指针与二维数组： int buf[10] int buf1[3][4]
一维数组名：指向是该行第一列
buf+0第一列 buf+1第二列
二维数组名：指向是某一行的地址
1、buf1+0第一行 buf1+1 第二行 buf1行地址
2、由于buf1[0] buf1[1] buf1[2]三个一维数组成的一个int buf1[3][10]的二维数组
所所以buf1[0]等价一维数组的名字（列）
buf1[0]+0第一行的第一列 buf1[0]+1第一行的 第二列的地址
3、引用内容：必须确定到行和列
buf1[2][2],*(buf1[2]+2),*(*(buf1+2)+2),(*(buf1+2))[2]
二维指针变量： 类型 （*指针变量）[列]
2.4指针与结构体变量的关系：
结构体：自定义类型
结构体变量：分配空间按类型分配
2.4.1定义结构体指针变量： struct 类型* 变量名
2.4.2引用成员：
变量.成员；
指针->成员；
（*指针）.成员；
注：指针变量必须指向一个元素
优先级：
. > * > 运算符 > 逻辑运算符 > 赋值
2.4.3结构体指针数组：
类型* 数组名[长度];
struct people* buf[10];
指针与数组的关系 :
#include<stdio.h>
void main()
{
/*
//定义变量：根据类型分配空间 类型 变量名;
int a=100;
printf("%x\n",&a);
//指针变量：存储指针的变量 类型* 变量名;
int* pa=&a;
//引用变量：引用变量的内容
printf("%d %x\n",a,pa);
printf("%d\n",*pa);
*/
//指针与数组的关系 ：
//定义数组：类型 数组名[长度];
//定义整型数组：
// int buf[10]={1,2,3,4,5,6,7,8,9,10}; //整型数组：专门存放整型的值
//引用数组：下标法 指针法
// printf("%d %d\n",buf[2],*(buf+2)); //指针法： 指针+2 向高位移动2个元素，指向第3个元素的地址
//指针数组：专门存入指针的数组
int a=100,b=200,c=300,d=400,e=500;//分配空间：地址
int* buf[]={&a,&b,&c,&d,&e,NULL};
printf("%d\n",sizeof(buf));
//引用数组：下标法 名[下标]
printf("&b=%x buf[1]=%x %d\n",&b,buf[1],*buf[1]);
/*
int i=0;
for(i=0;i<5;i++)
{
printf("%d\n",*buf[i]);
}
*/
int i=0;
int listen=**(buf+0);
for(i=1;buf[i]!=NULL;i++)
{
if(listen< **(buf+i))
listen=**(buf+i);
}
printf("%d\n",listen);
//通过buf查找指向最大值
}二维数组与指针的关系 :
#include<stdio.h>
//二维数组与指针的关系
void main()
{
//定义一维数组：类型 数组名[长度];
int buf[10]={1,2,34,5,6,7,8,9,10}; //分配空间
printf("%x %x\n",buf,&buf[0]);//数组名：首地址
printf("%x %x\n",buf,buf+1);
//引用内容：下标法 指针法
printf("%d %d\n",buf[2],*(buf+2));//buf[2]==*(buf+2)
//定义二维数组：分配空间
int buf1[3][10]={{0,1,2,3,4,5,6,7,8,9},
{10,11,12,13,14,15,16,17,18,19},
{20,21,22,23,24,25,26,27,28,29}};
//数组名：首地址：
printf("%x %x\n",buf1,&buf1[0][0]);
printf("%x %x\n",buf1,buf1+1);//buf某一行 行
printf("%x %x %x\n",buf1[0],*(buf1+0),*(buf1+0)+1);//buf[0]第一行的第一列 列
//引用元素的内容:第三行 第三列
printf("%d %d %d %d\n",buf1[2][2],*(buf1[2]+2),*(*(buf1+2)+2),(*(buf1+2))[2]);
}指针与结构体的关系 :
#include<stdio.h>
//学生（id，姓名，成绩）
struct student
{
//属性：声明属性
int id;
char name[10];
float score;
};
void main()
{
/*
//定义结构体变量:分配空间
struct student lm={1001,"lm",99};
printf("%d\n",sizeof(lm));
//输出地址
printf("%x\n",&lm);
//定义结构体指针变量：专门存放指针的变量
struct student* ps=&lm;
//引用成员：
printf("%s %d\n",lm.name,lm.id);
printf("%s %s\n",ps->name,(*ps).name); //. > *
//定义指针变量：
struct student* ps1=NULL;
if(NULL!=ps1)
printf("%s\n",ps1->name,(*ps).name);
*/
/*
//结构体变量：按类型分配
struct student lm={1001,"lm",99};
struct student zhl={1002,"zhl",100};
struct student hxs={1003,"hxs",59};
//结构体的指针数组：
struct student* pe[4]={&lm,&zhl,&hxs};
printf("%d\n",sizeof(pe));
//引用
int i=0;
for(i=0;pe[i]!=NULL;i++)
printf("%s %d %f\n",pe[i]->name,(*(pe+i))->id,(*pe[i]).score); // 变量.成员
*/
//二维数组：由多个一维数组成的二维数组
struct student s[3][2]={{{1001,"lm",99},{1002,"zyf",100}},\
{{2001,"zs",89},{2002,"ls",59}},\
{{3001,"wh",67},{3002,"zl",65}}
};
printf("%x,%x\n",s,s+1);//s行指针 s第一行 s+1第二行
printf("%x,%x\n",s[0],s[0]+1);//列指针
printf("%x\n",*(s+0)); //下标法与指针互换
//引用内容：
printf("%s\n",(*(*(s+2)+1)).name);
}定义二维指针变量 , 引用二维数组元素 .
#include<stdio.h>
void main()
{
//定义二维数组：
int buf[3][4]={{1,2,3,4},{21,22,23,24},{31,32,33,34}};
//引用：数组名就是首地址（buf行指针 ）
//printf("%x %x\n",buf+1,buf); //行指针+1 指向下一行 16Byte
//二维指针变量：
int (*pbuf)[4]=buf; //(笔试中)
int* pline=buf[0];
int i=0;
for(i=0;i<12;i++)
{
printf("%d\n",*(pline+i));
}
printf("%d %d\n",pbuf,pbuf+1); //行指针
printf("%d %d %d %d\n",pbuf[0],pbuf[0]+1,pbuf[1],pbuf[1]+1); //列指针
//引用元素
printf("%d %d\n",buf[1][1],pbuf[1][1] );
printf("%d %d\n",*(buf[1]+1),*(pbuf[1]+1) );
printf("%d %d\n",*(*(buf+1)+1),*(*(pbuf+1)+1) );
printf("%d %d\n",(*(buf+1))[1],(*(pbuf+1))[1] );
/*
//求每一列的平均值 [行][0]
int i=0,j,sum=0;
for(j=0;j<4;j++)//列
{
sum=0;
for(i=0;i<3;i++)//行
{
sum += *(*(pbuf+i)+j);
}
printf("ave=%d\n",sum/3);
}
*/
}