大学C语言期末考试练习题（带详解答案） 

}

max(int x, int y) { int z;

z=x>y? x : y; return(z) ; }

运行结果为： Max is 8

指针

1.

# include < stdio .h > main ( )

{ int x[ ] = {10, 20, 30, 40, 50 }; int *p ; p=x;

printf ( “%d”, *(p+2 ) ); } 运行结果为： 30

首先定义一个整型数组x，x的长度为5;然后定义一个指针变量p;对p进行初始化，将数组x的地址赋给p。因此此时p中存放的数组x的首地址，即数组中第一个元素x[0]的地址。

然后执行printf语句，输出表达式*(p+2)的值。p+2表示以p当前指向的位置起始，之后第2个元素的地址，即a[2]的地址。*(p+2)则表示该地址内所存放的内容，即a[2]的值30,因此输出30

2.

#include main( )

{ char s[]=”abcdefg”; char *p; p=s;

printf(“ch=%c\\n”,*(p+5)); }

运行结果为： ch=f

首先定义一个字符型数组s，并用字符串abcdefg对s进行初始化; 然后定义一个字符型指针变量p; 对p进行初始化，将数组s的地址赋给p。因此此时p中存放的数组s的首地址，即数组中第一个元素s[0]的地址。

然后执行printf语句，输出表达式*(p+5)的值。p+5表示以p当前指向的位置起始，之后

第5个元素的地址，即a[5]的地址。*(p+5)则表示该地址内所存放的内容，即a[5]的值f, 因此输出ch=f

3.

#include main ( )

{ int a[]={1, 2, 3, 4, 5} ； int x, y, *p； p=a；

x=*(p+2)；

printf(\：%d \\n\； }

运行结果为: 1:3

首先定义一个整型数组a，并对a进行初始化; 然后定义整型变量x,y，整型指针变量p; 再将数组a的地址赋给p。因此此时p中存放的数组a的首地址，即数组中第一个元素a[0]的地址。执行x=*(p+2)；p+2表示以p当前所指向的位置起始，之后第2个元素的地址，即a[2]的地址。*(p+2)则表示该地址内所存放的内容，即a[2]的值3，然后再把3赋给x

然后执行printf语句，先输出表达式*p的值。此时*p表示的是p所指向变量的内容，即a[0]的值1。再输出一个冒号。然后再输出x中的值3。

4.

#include main()

{ int arr[ ]={30,25,20,15,10,5}, *p=arr; p++;

printf(“%d\\n”,*(p+3)); }

运行结果为：10

首先定义一个整型数组arr，并对arr进行初始化; 然后定义整型指针变量p; 再将数组arr的地址赋给p。因此此时p中存放的数组arr的首地址，即数组中第一个元素a[0]的地址。

执行p++，即p=p+1。p+1表示以p当前所指向的位置起始，之后第1个元素的地址，即arr[1]的地址，然后再将arr[1]的地址赋给p，执行完此语句后，p不再指向arr[0]，而是指向arr[1]。

然后执行printf语句，输出表达式*(p+3)的值。p+3表示以p当前指向的位置起始(此时p指向arr[1])，之后第3个元素的地址，即arr[4]的地址。*(p+3)则表示该地址内所存放的内容，即arr[4]的值10, 因此输出10

5.

#include main( )

{ int a[ ]={1, 2, 3, 4, 5, 6};

int x, y, *p; p = &a[0]; x = *(p+2); y = *(p+4);

printf(“*p=%d, x=%d, y=%d\\n”, *p, x, y); }

运行结果为： *p=1, x=3, y=5

首先定义一个整型数组a，并对a进行初始化; 然后定义整型变量x,y，整型指针变量p; 再将数组元素a[0]的地址赋给p。

执行x=*(p+2)；p+2表示以p当前所指向的位置起始，之后第2个元素的地址，即a[2]的地址。*(p+2)则表示该地址内所存放的内容，即a[2]的值3，然后再把3赋给x

执行y = *(p+4); p+4表示以p当前所指向的位置起始，之后第4个元素的地址，即a[4]的地址。*(p+4)则表示该地址内所存放的内容，即a[4]的值5，然后再把5赋给y

执行printf语句，先输出表达式*p的值。此时*p表示的是p所指向变量的内容，即a[0]的值1。再输x的值3。再输出y的值5。

6.

#include main( )

{ static char a[ ]=”Program”, *ptr; for(ptr=a, ptr

运行结果为： Porm

首先定义一个字符型数组a，并对a进行初始化; 然后定义字符型指针变量p; 执行for语句 ptr=a为表达式1，将数字a的地址赋给ptr；表达式2（循环条件）ptr

执行putchar(*ptr); 即输出*ptr所对应的字符。此时ptr指向数组中的第1个元素，即 a[0],因此*ptr表示a[0]中的值，即’P’.

执行完循环体，转向执行表达式3，即ptr= ptr+2。ptr+2表示以ptr当前所指向的位 置起始，之后第2个元素的地址,即a[2]的地址，然后将a[2]的地址赋给ptr。a[2]的地 址等价于a+2，因此循环条件ptr

执行putchar(*ptr); 即输出*ptr所对应的字符。此时ptr指向数组中的第3个元素，即 a[2],因此*ptr表示a[2]中的值，即’o’.

执行完循环体，转向执行表达式3，即ptr= ptr+2。ptr+2表示以ptr当前所指向的位 置起始，之后第2个元素的地址,即a[4]的地址，然后将a[4]的地址赋给ptr。a[4]的地 址等价于a+4，因此循环条件ptr

执行putchar(*ptr); 即输出*ptr所对应的字符。此时ptr指向数组中的第5个元素，即

a[4],因此*ptr表示a[4]中的值，即’r’.

执行完循环体，转向执行表达式3，即ptr= ptr+2。ptr+2表示以ptr当前所指向的位 置起始，之后第2个元素的地址,即a[6]的地址，然后将a[6]的地址赋给ptr。a[6]的地址等价于a+6，因此循环条件ptr

执行putchar(*ptr); 即输出*ptr所对应的字符。此时ptr指向数组中的第7个元素，即 a[6],因此*ptr表示a[6]中的值，即’m’.

执行完循环体，转向执行表达式3，即ptr= ptr+2。ptr+2表示以ptr当前所指向的位 置起始，之后第2个元素的地址,即a[8]的地址，然后将a[8]的地址赋给ptr。a[6]的地址等价于a+8，因此循环条件ptr

#include char s[]=”ABCD”; main() { char *p;

for(p=s;p

printf(“%c %s\\n”,*p,p); }

运行结果为： A ABCD B BCD C CD D D

首先定义一个字符型数组s，并对s进行初始化; 数组s是全局变量，其有效范围从其定义开始至整个程序结束。

执行main函数 定义一个字符型指针p。

执行for语句 p=s为表达式1，将数字s的首地址赋给p；表达式2（循环条件）p

第1次执行循环体 执行printf(“%c %s\\n”,*p,p);即以字符%c形式输出*p所对应的字符。此时p指

向数组中的第1个元素，即s[0],因此*p表示a[0]中的值，即’A’. 然后再以字 符串%s的形式输出以p中地址为首地址的整个字符串，即输出ABCD

执行完循环体，转向执行表达式3，即p= p+1。p+1表示以p当前所指向的

位置起始，之后1个元素的地址,即s[1]的地址，然后将a[1]的地址赋给p。 s[1]的地址等价于s+1，因此循环条件p

向数组中的第2个元素，即s[1],因此*p表示s[1]中的值，即’B’. 然后再以字 符串%s的形式输出以p中地址为首地址的整个字符串，此时p指向s[1]，即 从s[1]开始，依次输出后面的字符串，因此又输出BCD

执行完循环体，转向执行表达式3，即p= p+1。p+1表示以p当前所指向的 位置起始，之后1个元素的地址,即s[2]的地址，然后将a[2]的地址赋给p。 s[2]的地址等价于s+2，因此循环条件p

向数组中的第3个元素，即s[2],因此*p表示s[2]中的值，即’C’. 然后再以字 符串%s的形式输出以p中地址为首地址的整个字符串，此时p指向s[2]，即 从s[2]开始，依次输出后面的字符串，因此又输出CD 执行完循环体，转向执行表达式3，即p= p+1。p+1表示以p当前所指向的

位置起始，之后1个元素的地址,即s[2]的地址，然后将s[2]的地址赋给p。 s[2]的地址等价于s+3，因此循环条件p

向数组中的第4个元素，即s[3],因此*p表示s[3]中的值，即’D’. 然后再以字 符串%s的形式输出以p中地址为首地址的整个字符串，即输出D 执行完循环体，转向执行表达式3，即p= p+1。p+1表示以p当前所指向的

位置起始，之后1个元素的地址,即s[3]的地址，然后将s[3]的地址赋给p。 s[3]的地址等价于s+4，因此循环条件p

结构体

1.

#include struct st { int x; int y;

} a[2]={5, 7, 2, 9} ; main() {

printf(\}

运行结果是： 14

首先是定义结构体st，st中共有两个整型成员x，y。 然后定义一个st类型的数组a，a的长度为2，即数组中含有两个st类型的元素，分别是a[0]和a[1]. 对a进行初始化，此题是按照储存顺序进行初始化，即将5赋给a[0]中的x（即a[0].x=5）; 将7赋给a[0]中的y（即a[0].y=7）; 将2赋给a[1]中的x（即a[1].x=2）; 将9赋给a[1]中的y（即a[1].y=9）;

执行main函数，输出表达式a[0].y*a [1].x的值，即7*2的值