------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------
第一讲 数组指针的概念及定义
一、数组指针
一个变量有地址，一个数组包含若干元素，每个数组元素都有相应的地址，指针变量可以指向数组元素（把某一元素的地址放到一个指针变量中），所谓数组元素的指针就是数组元素的地址。
用一个指针变量指向一个数组元素，那么这个指针变量就是数组指针。
int *p;
p = &a[0]; ----->等价于 p =a;
int *p = a;
或 int *p = &a[0];
注意：
1）数组名a不代表整个数组，只代表数组首元素的地址。
2） "p =a ;"的作用是 "把a数组的首元素的地址赋给指针变量p",而不是"把数组a各元素的值赋给p"
第二讲 数组指针初始化和使用方法
一、使用指针引用数组元素
数组指针如何访问数组的元素：
1）p+1 表示指向数组的下一个元素
2）p-1 指向数组的上一个元素
1 #include <stdio.h>
2
3 int main(itn argc , const char * argv []){
4
5 int a[4]={1,2,3,4};
6 printf("&a[0]=%p\n",&a[0]); //0x7fff5fbff7d0
7 printf("&a[1]=%p\n",&a[1]); //0x7fff5fbff7d4
8 printf("&a[2]=%p\n",&a[2]);
9
10 //数组指针
11 int *p = a; // p指向数组的第一个元素
12 printf ("p = %p\n",p);
13 //p+1*sizeof（int）
14 pirntf ("p+1= %p\n",p+1); //== &a[1] ; 0x7fff5fbff7d4
15 printf ("a+1 = %p\n",a+1);
16
17 //取的p+1对应的存储单元的内容
18 printf(" *(p+1)=%d\n",*(p+1)); //2
19 printf(" *(a+1)=%d\n",*(a+1));
//使用数组指针和使用数组名的区别
//p是一个指针变量，既然是一个变量，它存放的值是可以改变的
for (int i = 0;i<4;i++){
printf("%d\t",*p++); //1 2 3 4 或者写 *（p+i）
}
//数组名++ 是错误的， 数组名是一个常量 ，所以 *a++ 是错误的
20 return 0;
21 }
结论：
引用一个数组元素，可用下面两种方法：
(1)下标法，如a[i]形式
(2)指针法，如 *(a+i) 或*(p+i)
(3)a是常量(a++错误),p是变量(p++正确)
解题思路：
引用数组中各元素的值有3种方法：
1.下标法;
2.通过数组名计算数组元素地址，找出元素的值;
3.指针
总结：
对于一个一维数组来说
int a[5];
1)获取 a[i]的地址有几种方法？
1.&a[i]
2.a+i
3. int *p = a;
p+i;
2)获取 a[i]的值有几种方法？
1.a[i]
2. *(a+i)
3. int *p = a;
*(p+i)
4. *(&a[i])
第三讲 应用：逆序数组
思考&实现：
用指针将数组a中n个整数按相反顺序存放
解题思路：将a[0]与a[n-1]对换，......将a[4]与a[5]对换。
注意：a[i]= *(a+i);
#include <stdio.h>
/*
逆序一个数组
a 数组名
len 数组长度
*/
void nixuArray(int a[],int len ){
//定义数组指针
int *p = a;
//定义下标
int i=0,j=len-1;
int temp;
while (i<j){
//交换a[i]和a[j]
temp = *(p+i);
*(p+i) = *(p+j);
*(p+j) = temp;
//修改下标
i++,j--;
}
}
int main(int argc, const char *argv[]){
int arr[10]={1,2,3,4,5,6,7,8,9,10};
//调用函数逆序数组
nixuArray(arr,10);
//遍历数组
for (int i= 0;i<10;i++){
printf("%d\t",arr);
}
return 0;
}
第四讲 一维指针数组
一、一维指针数组
一个数组的元素值为指针则是指针数组。（存放（指针）地址的数组）
指针数组是一组有序的指针的集合。指针数组的所有元素都必须是具有相同存储类型和指向相同数据类型的指针变量。指针数组说明的一般形式为：
类型说明符（数据类型） * 数组名[数组长度]
1 /*
2 指针数组的使用：
3 int a = 3,b=4 , c= 5;
4 int *pa[3]={&a,&b,&c};
5
6 pa[0] a的地址
7 pa 数组的首地址，又是pa[0]的地址
8
9
10
11 */
12 #include <stdio.h>
13
14 int main(int argc , const chaar * argv[]){
15
16 int a=3,b=4,c=5;
17 int *pa[3] ={&a,&b,&c};
18 //打印的是指针数组的第一个元素的值
19 printf("&a = %p\n",&a);
20 printf("pa[0] = %p\n",pa[0]);
21 //打印指针数组的首地址
22 printf(" pa = %p\n", pa);
23 printf(" &pa[0] =%p\n",&pa[0]);
24
25 // 访问a的值 a= 3
26 printf ("*(&a) = %d\n",*(&a));
27 printf(" *(pa[0])=%d\n",*(pa[0]));
28
29 //使用数组名来访问a的值
30 // *pa == *(pa[0]) pa[0] (a的地址)
31 printf("%d\n",**pa);
32
33 int a1[2][2] = {1,2,3,4};
34 int *pa1[2] = {a1[0],a1[1]};
35 printf("**pa1 =%d\n",**pa1); // 1
36
37 printf("**(pa1+1) =%d\n",**(pa1+1)); // 3
38
39
40 return 0;
41 }
第五讲 指针变量之间运算
一、指针变量之间的算术运算
1.两指针变量减法运算
两指针变量相减所得之差是两个指针所指数组元素之间相差的元素个数。
实际上是两个指针值（地址）相减之差再除以该数组元素的长度（字节数）。
2.两个指针之间的减法运算
(1) 0x0006 - 0x0003 = 3(意义不大)
(2) 常见的用法：两个指针都指向同一个数组
1.判断两个指针变量指向的元素是否连续
他们相减的结果是 1 的绝对值
2.判断两个指针变量之间相隔几个元素
int a[5]= {1,2,3,4,5};
int * p =a ; //p指向了数组的第一个元素
int *p1 = &a[3]; // p指向了数组的第四个元素
//地址差值 (p1 - p) * sizeof(int )
printf("p - p1 = %ld\n",p - p1); // -3
printf("p1 - p = %ld\n",p1 - p); // 3
//如果两个指针变量指向同一个元素，那么他们相减的结果是 0
注意： 两个指针变量之间没有加法运算 （加法可能越界）
3.两个指针之间的关系运算
// p1>p
// 1 表示p1在高位
// 0 p在高位或者他们指向了同一个位置
第六讲 用数组名访问二维数组
一、用数组名访问二维数组
int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
a[0]+i 称为列指针
a+i 称为行指针
1 #include <stdio.h>
2 int main (int argc , const char * argv[]){
3
4 int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
5 //列指针
6 //a[0] == &a[0][0] a[0]+1== &a[0][1] a[0+2] == &a[0][2]
7 printf("&a[0][1]= %p\n",&a[0][1]);
8 printf("a[0]+1 = %p\n",a[0]+1);
9 printf("*(a[0]+1)= %d\n",*(a[0]+1)); //3
10 printf("&a[0][2]= %p\n",&a[0][2]);
11 printf("a[0]+2 = %p\n",a[0]+2);
12 //行指针 a[0] a[1] a[2]
13 //a+1 //第二行的首地址
14 //a+2 //第三行的首地址
15 printf("a[1] =%p\n",a[1]);
16 printf("a+1 = %p\n",a+1);
17
18 printf("a[2] =%p\n",a[2]);
19 printf("a+2 =%p\n",a+2);
20 return 0;
21 }
// a+1 第二行第一个元素的地址
// *(a+1) == &a[1][0]
print( "*(a+1) = %p\n",*(a+1));
printf("&a[1][0]= %p\n",&a[1][0]); //等价上面
// a[i]+j 获取的 &a[i][j]
//*(a[i]+j) 获取a[i][j]
//a[i] *(a+i)
//*(*(a[i]+j)) ------> a[i][j]
1 //a[i]+j //获取的 &a[i][j]
2 //*(a[i]+j) //获取a[i][j]
3 //a[i] //*(a+i)
4 //*(*(a+i)+j) // a[i][j]
5 int main(int argc ,const char * argv[]){
6 for (int i= 0;i<3;i++){
7 for(int j= 0;j<4;j++){
8
9 printf("%d\t",*(a[i]+j)); //打印二维数组
10 printf("%d\t", *(*(a+i)+j)); //等价上面
11
12 }
13 }
14 return 0;
15 }
二、普通指针访问二维数组
1 #include<stdio.h>
2 int main(int argc , const char * argv[]){
3
4 int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
5 // a[0] 1 3 5 7
6 // a[1 ] 9 11 13 15
7 // a[2] 17 19 21 23
8 int *p = a; //第一行的首地址 应该是**p =a;
9 for(int i = 0; i< 12; i++){
10
11
12 printf("%d\t",*(p+i));
13
14 }
15 return 0;
16 }
17 // 以上这样写是不妥的 ,最好不要这么写
第七讲 二维数组指针定义、初始化
一、二维数组指针的定义、初始化
二维数组名是指向行的，它不能对如下说明的指针变量p直接赋值
二维数组指针变量说明的一般形式为：
数据类型 （* 指针变量名）[二维数组列数];
其中"类型说明符"为所指数组的数据类型， "*"表示其后的变量是指针类型。
1 // 如要将二维数组赋给一指针，应这样赋值:
2
3 int a[3][4];
4 int (*p)[4]; //该语句是定义一个数组指针，指向含4个元素的一维数组。
5
6 p = a; //将该二维数组的首地址赋给p，也就是a[0]或&a[0][0]
7
8 p++; //将该语句执行过后，也就是p = p+1;p跨过行a[0][]指向了行a[1][]
9
所谓数组指针也称只想一维数组的指针，亦称行指针。
// 如何用
1 /*
2 数组指针：
3 定义一个指针变量，让这个指针变量指向一维数组的元素
4
5 二维数组指针
6 行指针，用来指向二维数组的每一行，存放的是行的首地址
7
8 定义格式： 数据类型 （*行指针变量名）[数组的第二维的长度];
9
10 二维数组指针的初始化
11 int a[2][3];
12 int b[2][2];
13 float f1[4][4];
14 // 假设我要定义一个指向数组a的行指针
15 // a[i] = *(a+i)
16 // a= &a[o][o] = &a[0] = a[0]
17 int (*p)[3] = a; //直接等于数组名
18
19 //二维数组指针的使用
20 *(*(p+i)+j) 或者 *(*(p++)+j)
21
22 */
23
24 #include <stdio .h>
25 int main (int argc , const char * argv[]) {
26 int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
27
28 //二维数组指针
29 //二维数组指针可以替代数组名去使用
30 int (*p)[4] = a;
31 for (int i= 0 ; i<3 ;i+=){
32 for (int j = 0 ; j< 4 ; j++){
33 //遍历数组
34 printf("%d\t",*(*(p+i)+j);
35
36 }
37 printf("\n");
38 }
39 return 0;
40 }
第八讲 指针数组和二维数组指针变量的区别
重点理解这两者的区别:
int *pa[3]={&a,&b,&c}; //pa是一个指针数组
int *pa1[2] = {a[0],a[1]}
int (*pa)[3]; //二维数组指针
二维数组指针变量是单个的变量，其一般形式中"(*指针变量名)"两边的括号不可少。而指针数组类型表示的是多个指针（一组有序指针）在一般形式中"*指针数组名"两边不能有括号。
例如:
int (*p)[3]; 表示一个指向二维数组的指针变量。该二维数组的列数为3或分解为一维数组的长度为3.
int *p[3] 表示p是一个指针数组，有三个下标变量p[0],p[1],p[2]均为指针变量。
原文：http://www.cnblogs.com/xiaokang520/p/5062325.html