C语言指针_06

地址和指针的概念：

内存区的每一个字节有一个编号，这就是“地址”。如果在程序中定义了一个变量，对程序进行编译时，系统就会给这个变量分配内存单元。

在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     }