「C语言回顾之旅」第一篇：指针详解-白红宇

说明：

最近学校课程开设了《数据结构》的课程，无疑，数据结构的重要性在IT生涯的进阶路上是不可置疑的，也常说，数据结构是专业性与非专业性的分界线。所以无论以后走的是什么方向，毕竟是读计算机专业的，所以必须学好数据结构的。虽然目前我给自己定的方向是走运维／系统架构方向的，可有句话说得好，不懂开发的运维注定会被淘汰，在IT这一行，要让自己变得更加强大。最近也一直在学Python，感觉还不错，学数据结构相信对自己也肯定有好处的，对一些较为底层的知识有些了解和理解，这样才能走得更远！

无疑C语言就很重要了，而在C语言当中，数组／指针／结构体／链表等这些都是非常重要的，所以根据往前自己的学习经验，需要把C语言中的指针之后等更深入的知识好好再回顾和总结一遍，为学好数据结构打下坚实的基础吧！

一.指针变量

1.定义指针变量

·变量的指针包含两方面信息：指向变量的地址和指向存储单元的数据类型；

·定义指针变量需要指定基类型，方法如下：

                         
int
*pointer;

·基类型说明存储单元的数据类型，指针的值即是所指向变量的地址；

·注意下面的一个赋值为非法的：

                         
*pointer = 
100
;    ===>左右类型不一致，赋值非法

·基于内存的地址编址可知，内存的值是无符号整型；

·为指针变量赋初值时注意是否有乱指的情况（即指向程序不授权的地址，会出错），会有下面三种情况：

                         
1
.正确指向本程序的变量    ===>正确
2
.指向其它程序未授权的地址    ===>非法
3
.未赋初值，只有随机值，指向未知地方    ===>非法
        
      

·可看下面一个非法的示范：

                         
#
include
<stdio.h>
void
swap(
int
*p1, 
int
*p2)
{ 
  
int
*p3;        ===>定义p3指针变量时已有初值，为随机值
  
*p3 = *p1;    ===>修改p3指向的值，会出现“未授权”的情况，即程序试图去修改一个未知地方的值
  
*p1 = *p2;            这显然是会引起错误的。
  
*p2 = *p3;
}
        
      

2.引用指针变量

·两个重要的符号：

                         
&    取地址运算符，＆a取变量a的地址
*    指针运算符，*p取指针p所指向的变量的值

·常用的三种指针引用：

（1）对指针变量赋值

                         
pointer = ＆a    ===>把a的地址赋给指针变量，或让pointer指向a

（2）引用指针变量指向的值

                         
printf(
"%d"
,*pointer);    ===>输出a的值

（3）直接引用

                         
printf(
"%d"
,pointer);    ===>直接输出指针变量的值，是一个内存地址

3.指针变量作用之一：作函数参数

·编写一个交换两数值的程序，用指针实现，代码如下：

a.main函数代码如下：

                         
#
include
<stdio.h>
int
main(
void
)
{ 
  
int
a,b;
  
int
*p1,*p2;
  
printf(
"Please input a:"
);scanf(
"%d"
,&a);
  
printf(
"Please input b:"
);scanf(
"%d"
,&b);
  
printf(
"a=%d, b=%d\n"
,a,b);
  
p1 = &a;p2 = &b;
  
swap(p1,p2);
  
printf(
"Now, a=%d, b=%d\n"
,a,b);
  
return
0
;
}
        
      

b.swap函数代码如下：

                         
#
include
<stdio.h>
void
swap(
int
*p1, 
int
*p2)
{ 
  
int
temp;
  
temp = *p1;
  
*p1 = *p2;
  
*p2 = temp;
}
        
      

·编译，链接与执行：

                         
xpleaf@leaf:~/stuc$ gcc -o swap swap_main.o swap_sec.o
xpleaf@leaf:~/stuc$ ./swap
Please input a:
3
Please input b:
4
a=
3
, b=
4
Now, a=
4
, b=
3
        
      

二.指针与数组

1.数组元素的指针

·所谓数组元素的指针就是数组元素的地址；

·数组的引用有下标法和指针法，在编译时，最终数组引用的实现都是通过指针实现的；

·数组名实际为一地址常量（指针常量），指向数组的第一个元素，该地址值不可改变；

·可以以指针的操作方式来引用数组中的元素；

2.通过指针运算引用数组元素

·只讨论加减：

                         
p1+
1
：表示指向下
1
个元素，指针移动基类型个字节
p1-
1
：表示指向上
1
个元素，指针移动基类型个字节
p1+
2
：表示指向下
1
个元素，指针移动（基类型 * 
2
）个字节
        
      

·a[3]中，[ ]实际是取址运算符，等价于：*(a+3)；

·通过指针运算操作，编写一个遍历数组的程序：

a.代码如下：

                         
#
include
<stdio.h>
int
main(
void
)
{ 
  
int
a[
10
], *p, i;
  
for
(i = 
0
;i < 
10
;i++)
    
a[i] = i + 
10
;
  
p = a;
  
for
(i = 
0
;i < 
10
; p++, i++)
    
printf(
"a[%d]=%d  "
, i, *p);
    
printf(
"\n"
);
  
return
0
;
}
        
      

b.执行过程：

                         
xpleaf@leaf:~/stuc/shuzu$ gcc -c value.c 
xpleaf@leaf:~/stuc/shuzu$ gcc -o value value.o 
xpleaf@leaf:~/stuc/shuzu$ ./value 
a[
0
]=
10
a[
1
]=
11
a[
2
]=
12
a[
3
]=
13
a[
4
]=
14
a[
5
]=
15
a[
6
]=
16
a[
7
]=
17
a[
8
]=
18
a[
9
]=
19
        
      

3.数组名作函数参数

·显然与指针变量作函数参数是一致的，只是换个写法，即在定义或调用函数时，下面的功能是一致的：

a.创建函数时形式不一样，实际传递的还是指针：

                         
void
swap(
int
a[])
等价于
void
swap(
int
*a)
        
      

b.引用函数时，放入的都是指针：

                         
swap(a)    ===>实际放入的都是指针

·原理为：在编译时，最终数组引用的实现都是通过指针实现的；

4.指针与多维数组

--多维数组元素的指针

·创建一个如下的二维数组进行分析：

                         
a[
5
][
2
] = { 
{ 
1
, 
2
}, { 
3
, 
4
}, { 
5
, 
6
}, { 
7
, 
8
}, { 
9
, 
10
}};
        
      

·只从文字数字上看，二维数组与指针的关系会比较抽象，可用下面的示意图形象化：

·作如下重要说明：

a.二维数组名实则是一个指针变量，包含了指向的存储单元和数据类型；

b.二维数组名指针变量指向的数据类型为：一维数组名，即指针变量；

c.所以二维数组名应为多重指针，即指向指针的指针；

d.前面说[ ]实则为取址运算符，则a[1]，即为对多重指针a作运算：*(a+1)，从而得到多重指针a指向的第2个指针变量；

e.*(a+1)或者说a[1]实则就是普通的一维数组名，也是一个指针，因此一维数组是如何处理的，即可对其作相应处理；

f.**(a+1)或者a[1][0]，在这里就是对应的值3；

g.无论中间的指针指向如何复杂，根据数组的特性，最终的元素（在这里是数值），在内存中的存储空间是连续的。

--指向多维数组元素的指针变量

·根据一维数组和二维数组的特性，定义指向多维数组的指针变量时，有如下的两种方式：

a.定义二维数组指针所指向的一维数组指针变量，与前面指针变量指向一维数组是类似的；

b.定义指向二维数组名的二维数组指针变量，下面重点讨论；

·编写程序，通过指向二维数组的多重指针变量的运算来遍历二维数组：

a.代码如下：

                         
#
include
<stdio.h>
int
main(
void
)
{ 
  
int
a[
5
][
2
] = { 
                
{ 
1
,
2
},
                
{ 
3
,
4
},
                
{ 
5
,
6
},
                
{ 
7
,
8
},
                
{ 
9
,
10
}
                
};
  
int
(*p)[
2
], i, j;
  
p = a;
  
for
(i = 
0
;i < 
5
; i++)
    
for
(j = 
0
;j < 
2
;j++)
      
printf(
"a[%d][%d]=%d\n"
, i, j,*(*(p+i)+j));
  
return
0
;
}
        
      

b.执行过程如下：

                         
xpleaf@leaf:~/stuc/shuzu2$ ./value2 
a[
0
][
0
]=
1
a[
0
][
1
]=
2
a[
1
][
0
]=
3
a[
1
][
1
]=
4
a[
2
][
0
]=
5
a[
2
][
1
]=
6
a[
3
][
0
]=
7
a[
3
][
1
]=
8
a[
4
][
0
]=
9
a[
4
][
1
]=
10
        
      

·注意的是不能对p执行“(*p)++”操作，*p表示一个指针变量，值为地址常量，执行(*p)++，即要改变地址常量，这是非法的；

·可以执行p++操作，因为改变的只是变量p的值，即相当于重新给p赋值；

·一个有趣的现象如下：

a.在上面代码中添加如下一行代码：

                         
printf(
"print %d\n"
, *(*p+
3
));
        
      

b.会多出如下输出：

                         
print 
4

·虽然*p表示的是第一个一维数组，最多应该只有2个元素，而上面输出的是第二个一维数组的第二个元素；

·由此也可以知道数组元素的在内存中的连续性，以及对多重指针p执行操作时对取值的影响；

--用指向一维数组的指针作函数参数

·实则可以用指向一维数组元素和指向一维数组的指针作函数参数，注意二者的不同，这里只讨论前者；

·编写一个程序，用指向一维数组的指针变量作函数参数，遍历多维数组：

a.main函数代码如下：

                         
#
include
<stdio.h>
int
main(
void
)
{ 
  
int
a[
5
][
2
] = { 
                
{ 
1
,
2
},
                
{ 
3
,
4
},
                
{ 
5
,
6
},
                
{ 
7
,
8
},
                
{ 
9
,
10
}
                
};
  
int
(*p)[
2
], i,j;
  
p = a;
  
fun(p, 
5
);
  
return
0
;
}
        
      

b.fun函数代码如下：

                         
#
include
<stdio.h>
void
fun(
int
(*p)[
2
], 
int
n)
{ 
  
int
i, j;
  
for
(i = 
0
;i < n;i++)
    
for
(j = 
0
;j < 
2
;j++)
      
printf(
"a[%d][%d]=%d\n"
,i, i, *(*(p+i)+j));
}
        
      

c.执行过程如下：

                         
xpleaf@leaf:~/stuc/shuzu3$ gcc -o value3 value3.o value3_fun.o
xpleaf@leaf:~/stuc/shuzu3$ ./value3 
a[
0
][
0
]=
1
a[
0
][
0
]=
2
a[
1
][
1
]=
3
a[
1
][
1
]=
4
a[
2
][
2
]=
5
a[
2
][
2
]=
6
a[
3
][
3
]=
7
a[
3
][
3
]=
8
a[
4
][
4
]=
9
a[
4
][
4
]=
10
        
      

三.指针与字符串

1.字符串引用方式

·字符串实则是用数组存放，因此有两种方式可以引用字符串；

--常规方式：通过格式声明%s引用

·编写一个程序，通过％s引用字符串：

a.代码如下：

                         
#
include
<stdio.h>
int
main(
void
)
{ 
  
char string[] = 
"I hope CL can be my girlfriend."
;
  
printf(
"%s\n"
,string);
  
return
0
;
}
        
      

b.执行过程如下：

                         
xpleaf@leaf:~/stuc/str$ gcc -c str1.c 
xpleaf@leaf:~/stuc/str$ gcc -o str1 str1.o
xpleaf@leaf:~/stuc/str$ ./str1 
I hope CL can be my girlfriend.

·通过％s可以输出字符串是因为：string代表字符串的首地址，即string数组的首地址，且后面默认添加'\0'标记；

--字符指针变量方式

·编写一个程序，通过指针变量实现上面的功能：

                         
#
include
<stdio.h>
int
main(
void
)
{ 
  
char *string = 
"I hope CL can be my girlfriend."
;
  
printf(
"%s\n"
,string);
  
return
0
;
}
        
      

·原理为把字符串首地址赋给string，string不断指向字符串中的每一个字符，直到指向字符串末尾标记“\0”结束输出；

·根据上面分析，下面三种方法功能一致：

                         
*string = 
"I hope CL can be my girlfriend."
;    ===>直接定义初始化，让string指向字符串首地址
等价于
char *string;    ===>先定义char指针类型
string = 
"I hope CL can be my girlfriend."
===>让string指向字符串首地址
等价于
char string[] = 
"I hope CL can be my girlfriend."
;    ===>通过数组方式实现
        
      

·因为数组最终通过指针实现，上面三种方法实则一致；

2.字符指针作函数参数

·这与前面的一维数组遍历实则是一致的，无非就是对指针的引用，不再涉及；

·需要注意的是：字符数组（字符串）可以通过批量方式赋值（在初始化时才行），但数值型的数组则不可以；

3.指针与字符串的注意事项

--字符数组与字符串变量区分

·字符数组存放每一个字符，字符串变量只是存放一个地址；

--关于赋值方式

·可以对字符指针变量赋值，但不能对数组名赋值，以下赋值方式是非法的：

                         
char str[
14
];
str = 
"I hope CL can be my girlfriend."
;    ===>非法赋值
        
      

·非法赋值原因在于，在定义一维数组str时，数组名str已经为一地址常量，因此往后再对其赋值是非法的；

·但下面的初始化是可以的：

                         
char str[
14
] = 
"I hope CL can be my girlfriend."
;
        
      

·其它初始化方式上面已有提及，不再讨论；

--关于存储单元

·对数组分配若干个存储单元以存放不同元素，对字符指针变量则分配1个存储单元，大小可实际编译器；

·判断指针变量大小，可先定义指针变量，再用sizeof或strlen（不包括'\0'）即可；

--关于值是否可变

·可看下面的例子分析：

                         
char a[] = 
"I hope CL can be my girlfriend."
;
char *b = 
"I hope CL can be my girlfriend."
;
a[
2
] = 
'I'
;    ===>合法
b[
2
] = 
'I'
===>非法
        
      

·关于此内容，可用相关Python中的知识进行理解；

小结：

数组和字符指针变量最终在实现上还是有所区别的，数组会创建每一个变量，因此数组元素的值是可变的（对变量再进行赋值），有数组时通过指针操作实则是操作数组中的每一个变量，这些变量被赋值为字符常量；指针直接指向字符串某个字符，中间并没有变量，由于字符串常量都不可改变的，因此不能通过此方式修改字符串。