地址和指针的概念：
内存区的每一个字节有一个编号，这就是“地址”。如果在程序中定义了一个变量，对程序进行编译时，系统就会给这个变量分配内存单元。
在C语言中，对变量的访问有两种方式：
1）直接访问 例如：a = 6;
2）间接访问 例如：scanf("%d", &a);
调用函数时，把变量a的地址传给函数scanf，函数首先把该地址保存到一个单元中，然后把从键盘接收的数据通过所存储的地址保存到a变量中。
1 /*
2 *：取值操作符；
3 &：取址操作符
4 */
5 int i = 66;
6 int *pointer; // 注意：此处*，不是取值，而是定义指针变量！！
7 pointer = &i; // &取址操作符
8 printf("%d\n", *pointer); // *pointer 取值操作符
指针与指针变量
知道了一个变量的地址，就可以通过这个地址来访问这个变量，因此，又把变量的地址称为该变量的“指针”。
C语言中可以定义一类特殊的变量，这些变量专门用来存放变量的地址，称为指针变量。
在定义指针变量是要注意两点：
1)指针变量前面的*，表示该变量的类型为指针型变量，其一般形式为：类型说明符 *变量名；
其中，*表示这个一个指针变量，变量名即为定义的指针变量名，类型说明符表示该指针变量所指向的变量的数据类型。
2）定义指针变量是“必须”指定基类型。注意：只有整型变量的地址才能放到指向整型变量的指针变量中；例如：
1 // 错误！！ 2 float a; 3 int *pointer_1; 4 pointer_1 = &a;
指针变量只能存放地址！！
1 // 通过指针变量访问整型变量
2 int a = 88, b = 66;
3 int *pointer_1, *pointer_2;
4 pointer_1 = &a;
5 pointer_2 = &b;
6
7 printf("%d %d\n", a, b);
8 printf("%d %d\n", *pointer_1, *pointer_2);
9 /*
10 输出结果：
11 88 66
12 88 66
13 */
关于“&” “*”说明：‘&’‘*’两个运算符的优先级别相同，但按自右向左方向结合；
定义一个指针变量 int *p; p = &a[i]
引用一个数组元素，可以用：
1）下标法：如 a[i]
2）指针法：如*(a + i) 或 *(p + i)
注意：数组名即“翻译成数组的第一个元素的地址”(编译器会把数组名编译为地址，数组第一个元素的地址)
对”&“和”*“运算符再做些说明：
1 int a = 100; 2 int *pointer_1; 3 pointer_1 = &a;
1)&*pointer_1 的含义是什么呢 ？
解析：‘&’和‘*’两个运算符的优先级别相同，但它俩都是右结合性(自右向左方向结合)，因此先进行 *pointer_1的运算，即：*pointer_1 = a；在执行&运算，即：&a，为变量a的地址。
2)*&a 的含义是什么？
先进行 &a，为变量a的地址；在*运算，即取值运算，最终结果就是变量a；
3)(*pointer_1) ++ 相当于 a ++; 括号是必要的，因为’++‘ 和 ’*‘ 同一优先级别，而且也是右结合性。
数组，一个数组包含若干个元素，每个数组元素在内存中都占用存储单元，他们都有相应的地址，地址是连续的。
用数组名作为函数参数
1 // 编译时，是将arr按指针变量处理的，相当于将函数首部写成
2 // input(int *arr, 10);
3 // void input(int arr[], int n) 等价于 void input(int *arr, int n)
4 void input(int arr[], int n) {
5 printf("do something");
6 }
需要说明的是：C语言调用函数时，虚实结合的方法都是采用”值传递“方式，当用变量名作为函数参数时传递的是变量的值；当用数组名作为函数参数时，由于数组名代表的是数组首元素地址，因此传值的值是地址，所以要求形参为指针变量。
关于数组的一个常见错误：
1 char *c_strcpy (char destination[],const char source[]);
2 int main(void) {
3 char str1[] = "this is a very long string";
4 char str2[] = "this is a short string";
5 strcpy(str2, str1);
6 puts(str2);
7 return 0;
8 }
9
10 char *c_strcpy (char destination[], const char source[]) {
11 int size_of_array = sizeof source / sizeof source[0];
12 for (int i = 0; i < size_of_array; i++) {
13 destination[i] = source[i];
14 }
15 return destination;
16 }
出现错误的是第 11 行代码。我们知道，数组作为函数的参数，在本函数中 source 只是一个指针（地址，系统在本函数运行时，是不知道a所表示的地址有多大的数据存储空间，这里只是告诉函数：一个数据存储空间首地址），所以，sizeof source 的结果是指针变量 source 占内存的大小。一般在32位机上是4个字节。source[0] 是 int 类型，sizeof source 也是4个字节，所以，结果永远是1。
结论：获得数组长度，只能在数组定义所在的代码区中获取数组长度，才能获取正确的数组长度。
正确代码：
1 char *c_strcpy (char destination[], const char source[], int len);
2 int main(void) {
3 char str1[] = "this is a very long string";
4 char str2[] = "this is a short string";
5 int len = sizeof(str1) / sizeof(str1[0]);
6 c_strcpy(str2, str1, len);
7 puts(str2);
8 return 0;
9 }
10
11 char *c_strcpy (char destination[], const char source[], int len) {
12 for (int i = 0; i < len; i++) {
13 destination[i] = source[i];
14 }
15 return destination;
16 }
倒序输出数组中的值：
1 int main(int argc, const char * argv[]) {
2 int a[] = {34, 56, 89, 87, 1, 34, 67};
3 int count = sizeof(a)/sizeof(int);
4 int i;
5 reverse_pointer(a, count);
6 // reverse_arr(a, count);
7 for (i = 0; i < count; i ++) {
8 printf("%d\n", a[i]);
9 }
10 return 0;
11 }
12
13 // 方法一：倒序输出数组中的值(指针作为参数)
14 void reverse_pointer(int *x, int n) {
15 int *p, *i, *j, temp, m;
16 m = (n - 1) / 2;
17 i = x; // i指向数组的第一个元素
18 j = x - 1 + n; // j指向数组的最后一个元素
19 p = x + m; // p指向数组的中间一个元素,配对
20 for (; i < p; i ++ , j --) {
21 temp = *i;
22 *i = *j;
23 *j = temp;
24 }
25 }
26
27 // 方法二：倒序输出数组中的值(数组作为参数)
28 void reverse_arr(int arr[], int len) { // 形参arr是数组名，在此处仅是指针
29 int temp, i, j, m;
30 m = (len -1 ) / 2;
31 for (i = 0; i < m; i ++) {
32 j = len - 1 - i;
33 temp = arr[i];
34 arr[i] = arr[j];
35 arr[j] = temp;
36 }
37 }
1 // 找出数组中的最大值和最小值
2 void max_min_value(int arr[], int n) {
3 int *p, *array_end;
4 array_end = arr + n;
5 int max, min;
6 max = min = *arr;
7 for (p = arr + 1; p < array_end; p ++) {
8 if (*p > max) {
9 max = *p;
10 } else if (*p < min) {
11 min = *p;
12 }
13 }
14 }
归纳起来，如果有一个实参数组，想在函数中改变此数组中元素的值，实参与形参的对应关系有以下4种情况：
1) 形参和实参都用数组名，如
1 void func(int x[], int n) {
2 printf("do something");
3 }
4
5 void main(void) {
6 int a[10];
7 func(a, 10);
8 }
2) 实参用数组名，形参用指针变量，如
1 void func(int *p, int n) {
2 printf("do something");
3 }
4
5 void main(void) {
6 int a[10];
7 func(a, 10);
8 }
3) 实参形参都采用指针变量，如
1 void func(int *p, int n) {
2 printf("do something");
3 }
4
5 void main(void) {
6 int a[10], *p;
7 func(p, 10);
8 }
4) 实参为指针变量，形参为数组名，如
1 void func(int x[], int n) {
2 printf("do something");
3 }
4
5 void main(void) {
6 int a[10], *p;
7 func(p, 10);
8 }
多维数组与指针：
多维数组元素的地址，定义一个二维数组
1 int a[3][4] = {{1, 3, 5, 7}, {9, 11, 13, 15}, {17, 19, 21, 23}};
设二维数组的首行的首地址为2000，则：
一维数组里面存放的是二维数组元素的地址，二维数组里面存放的是二维数组元素的值！
1 // 定义二维数组，三行四列
2 int a[3][4] = {0, 1, 2, 3 , 4, 5, 6, 7, 8, 9, 10, 11};
3
4 // 打印 a[0][0] 首元素地址
5 printf("a=%p\n", a);
6 printf("*a=%p\n", *a);
7 printf("a[0]=%p\n", a[0]);
8 printf("&a[0]=%p\n", &a[0]);
9 printf("&a[0][0]=%p\n", &a[0][0]);
10
11 printf("\n");
12
13 // 打印 a[1][0] 的地址，第二行
14 printf("a+1=%p\n", a + 1);
15 printf("*(a+1)=%p\n", *(a + 1));
16
17 printf("\n");
18
19 // 打印 a[1][1] 的值
20 printf("*(a[1]+1)=%d\n", *(a[1]+1));
21 printf("*(*(a+1)+1)=%d\n", *(*(a+1)+1));
22
23 // 把二维数组 a 分解为一维数组 a[0],a[1],a[2]之后，设 p 为指向二维数组的指针变量，可定义为：
24 int (*p)[4];
25 // 它表示 p 是一个指针变量，它指向包含4个元素的一维数组。若指向第一个一维数组 a[0]，其值等于 a,a[0] 或 &a[0][0]
26
27 // 而 p + i 则指向一维数组 a[i]
28
29 // 结论： *(p + i) + j 是二维数组 i 行 j 列的元素的地址
30 // 而 *(*(p + i) + j) 是 i 行 j 列元素的值
31
32 // 二维数组指针变量说明的一般形式：
33 类型说明符 (*指针变量名)[长度]
34
35 // 其中“类型说明符”为所指数组的数据类型。
36 // “*”表示其后的变量是指指针类型。
37 // “长度”表示二维数组分别为多个一维数组时，一维数组的长度，也就是二维数组的列数
1 // 用指针输出二维数组的值
2 int a[3][4] = {0, 1, 2, 3 , 4, 5, 6, 7, 8, 9, 10, 11};
3 int (*p)[4];
4 int i, j;
5 p = a;
6 for (i = 0; i < 3; i ++) {
7 for (j = 0; j < 4; j ++) {
8 printf("%2d", *(*(p + i) + j));
9 }
10 }