练习题10及参考答案
1. 单项选择题
(1)在声明一个结构体类型时系统分配给它的存储空间是。
A. 该结构体类型中第一个成员所需存储空间
B. 该结构体类型中最后一个成员所需存储空间
C. 该结构体类型中所有成员所需存储空间的总和
D. 结构体类型本身并不占用存储空间,即系统并不给结构体类型分配存储空间【答】D
(2)下列说法不正确的是。
A. 下列结构体声明时,占据了5个字节的空间
struct stru
{
short int a;
short int b;
char c;
}
B. 结构体类型的成员名可以与程序中的变量名相同
C. 结构体类型的成员可以是一个结构体变量
D. 可以单独使用结构体变量中的成员,它的作用相当于普通变量
【答】声明结构体类型时不占据内存空间。本题答案为A。
(3)在定义一个结构体变量时系统分配给它的存储空间是。
A. 该结构体变量中第一个成员所需存储空间
B. 该结构体变量中最后一个成员所需存储空间
C. 该结构体变量中占用最大存储空间的成员所需存储空间
D. 该结构体变量中所有成员所需存储空间的总和
【答】D
(4)下列说法正确的是。
A. 结构体类型的每个成员的数据类型必须是基本类型
B. 结构体类型的每个成员的数据类型都相同,这一点与数组一样
C. 在声明结构体类型时,其成员的数据类型不能是结构体本身
D. 以上说法都不对
【答】D
(5)在定义一个共用体变量时系统分配给它的存储空间是。
A. 该共用体变量中第一个成员所需存储空间
B. 该共用体变量中最后一个成员所需存储空间
C. 该共用体变量中占用最大存储空间的成员所需存储空间
D. 该共用体变量中所有成员所需存储空间的总和
【答】C
(6)以下关于枚举的叙述不正确的是。
A. 枚举变量只能取对应枚举类型的枚举元素表中元素
B. 可以在定义枚举类型时对枚举元素进行初始化
C. 枚举元素表中的元素有先后次序,可以进行比较
D. 枚举元素的值可以是整数或字符串
【答】D
(7)以下关于typedef的叙述不正确的是。
A. 用typedef可以定义各种类型名,但不能用来定义变量
B. 用typedef可以增加新类型
C. 用typedef只是将已存在的类型用一个新的名字来代表
D. 使用typedef便于程序的通用
【答】使用typedef语句并不能创建新的类型,只是给定义的类型取一个新名字。本题答案为B。(8)设有如下定义:
struct stru
{
int x;int y;
};
struct st
{
int x;
float y;
struct stru *p;
} st1,*p1=&st;
以下引用正确的是。
A. (*p1).p.x
B. (*p1)->p.a
C. p1->p->x
D. p1.p->a
【答】C
(9)若有如下声明:
union data
{
char *p;
int n;
};
以下初始化正确的是。
A. union data a="Mary";
B. union data a={"Mary"};
C. union data a=10;
D. union data a={10};
【答】在共用体变量初始化时只能给一个成员赋初值。本题答案为B。
(10)下列用法正确的是。
A. typedef int INTEGER;INTEGER i,m;
B. typedef int char;char t,m;
C. typedef int[4] ARRAY;ARRAY n;
D. 以上都不对
【答】选项A正确;选项B中char为C语言已有的数据类型;选项C应改为:typedef int ARRAY[4];ARRAY n。本题答案为A。
(11)以下程序的运行结果是。
#include
struct node
{
int x;
char c;
};
void func(struct node b);
main()
{
static struct node a={10,'x'};
func(a);
printf("%d,%c\n",a.x,a.c);
}
void func(struct node b)
{
b.x=20;b.c='x';
}
A. 20,x
B. 10,x
C. x,10
D. x,20 【答】func()函数采用传值调用方式,形参的值不会传递到实参。本题答案为B。(12)以下程序的运行结果是。
#include
struct node
{
int x;
char c;
};
void func(struct node *b);
main()
{
static struct node a={10,'x'};
func(&a);
printf("%d,%c\n",a.x,a.c);
}
void func(struct node *b)
{
b->x=20;b->c='x';
}
A. 20,x
B. 10,x
C. x,10
D. x,20 【答】func()函数采用传址调用方式,形参的值会传递到实参。本题答案为A。(13)以下程序的运行结果是。
#include
main()
{
union
{
short int i[2];
long k;
char c[4];
} r,*s=&r;
s->i[0]=0x39;
s->i[1]=0x38;
printf("%lx\n",s->k);
}
A. 390038
B.380039
C. 3939
D. 3838
【答】B
(14)以下程序的运行结果是。
#include
union data
{
int i;
char c;
float f;
};
int n;
main()
{
union data a={'A'};
printf("%d\n",a.c);
}
A. A
B. 65
C. 65.000000
D. 以上都不对
【答】在共用体变量初始化时只能给一个成员赋初值,'A'对应的ASCII码为65。本题答案为B。(15)以下程序的运行结果是。
#include
main()
{
struct s
{
int n;
int *m;
} *p;
int d[5]={10,20,30,40,50};
struct s arr[5]={100,&d[0],200,&d[1],300,&d[2],400,
&d[3],500,&d[4]};
p=arr;
printf("%d,",++p->n);
printf("%d,",(++p)->n);
printf("%d\n",++(*p->m));
}
A.100,200,20
B.100,201,21
C.101,201,21
D.100,200,21
【答】C
2. 填空题
(1)以下程序的运行结果是。
#include
#pragma pack(1) /*参见10.1.3小节的特别说明*/
typedef struct
{
int no;
char *name;
char sex;
float score;
} STUD;
union u
{
int i;
char *p;
float f;
double d;
STUD s;
};
main()
{
printf("%d,%d\n",sizeof(STUD),sizeof(union u));
}
【答】其中char *name占用的字节数为4(所有指针变量所占长度均为4)。所以
sizeof(STUD)=4+4+1+4=13。而sizeof(union u)=max{4,4,4,8,13}=13。程序输出为:13,13
(2)以下程序的运行结果是。
#include
#pragma pack(1) /*参见10.1.3小节的特别说明*/
typedef union
{
long i;
int k[5];
char c;
} DATE;
struct date
{
int cat;
DATE cow;
double dog;
};
DATE max;
main()
{
printf("%d\n",sizeof(struct date)+sizeof(max));
}
【答】程序中DATE是共用体类型,date是一个结构体类型,有:
sizeof(DATE)=max{4,4*5,1}=20,sizeof(max)=sizeof(struct DATE)=20,sizeof(struct
date)=4+sizeof(DATE)+sizeof(double)=4+20+8=32
程序输出为:
52
(3)以下程序的运行结果是。
#include
main()
{
int j;
union
{
short int a;
long b;
unsigned char c;
} m;
m.b=0x12345678;
printf("%x,",m.a);
printf("%x\n",m.c);
}
【答】short int型占2个字节,long型占4个字节,在执行m.b=0x12345678语句后,第0个字节存放0x78,第1个字节存放0x56,第2个字节存放0x34,第3个字节存放0x12。所以输出为:
5678,78
(4)以下程序的运行结果是。
#include
main()
{
union un
{
short int a;
char c[2];
} w;
w.c[0]='A';w.c[1]='a';
printf("%o\n",w.a);
}
【答】这里是共用体,a和c成员共享相同的存储区域。程序输出为:
60501
(5)以下程序的运行结果是。
#include
main()
{
struct person
{
char name[9];
int age;
};
static struct person st[10]={"John",17,"Paul",19,"Mary",
18,"Smith",16};
printf("%c\n",st[2].name[0]);
}
【答】st是一个结点体数组,st[2].name为“Mary”,则st[2].name[0]=‘M’。程序输出为:M
(6)以下程序的运行结果是。
#include
#define P printf
#define C2 "%c""%c""\n"
#define S2 "%s""%s""\n"
main()
{
static struct st
{
char c[5];
char *s;
} s1={"cake","milk"};
static struct t
{
char *str;
struct st ss1;
} s2={"work",{"time","free"}};
P(C2,s1.c[0],*s1.s);
P(S2,s1.c,s1.s);
P(S2,s2.str,s2.ss1.s);
P(S2,++s2.str,s2.ss1.s+2);
}
【答】根据宏定义的展开和结构体变量初始化的方法,程序输出如下:
cm
cakemilk
workfree
orkee
(7)以下程序的运行结果是。
#include
main()
{
enum type {a=1,b=3,c,d,f=-2,g};
printf("%d,%d,%d\n",c,d,g);
}
【答】枚举量c在b之后,故c=c+1=4,d在c之后,故d=c+1=5,g在f之后,故
g=f+1=-1。程序输出为:
4,5,-1
(8)以下程序的运行结果是。
#include
main()
{
struct st
{
int n;
struct st *np;
};
struct st a[3],*p;
a[0].n=7;a[0].np=&a[1];
a[1].n=9;a[2].np=&a[2];
a[2].n=11;a[0].np='\0';
p=&a[0];
printf("%d\n",++p->n);
}
【答】8
(9)以下程序的运行结果是。
#include
main()
{
struct ks
{
int a;
char *b;
} as[]={5,"abcd",6,"efgh"};
struct ks *p=as;
printf("1.%s\n",as[1].b);
printf("2.%s\n",p->b++);
printf("3.%s\n",p->b);
printf("4.%s\n",p++->b);
printf("5.%s\n",p->b);
}
【答】as是一个结构体数组,有两个元素,每个元素都是一个结构变量。p是指向ks类型结构的指针变量且它指向了as的第一个元素。程序中第一个表达式传给printf()函数的第二个结构体的成员变量b的内容,即指向字符串"efgh"的指针。第二个表达式传给printf()函数的第一个结构体成员变量b的内容(字符串"abcd"的地址),这个表达式执行完后将结构的成员b增1,使其指向字符串的下一字符。第三个传递"bcd"的地址。第四个传递的地址与第三个相同,但表达式执行完后将变量p增1,使其指向结构体数组的第二个元素。第五个传递字符串"efgh"的地址。程序输出为:
1.efgh
2.abcd
4.bcd
5.efgh
(10)以下程序的运行结果是。
#include
struct s1
{
char *s;
struct s1 *sip;
};
void swap(struct s1 *p1,struct s1 *p2)
{
char *temp;
temp=p1->s;
p1->s=p2->s;
p2->s=temp;
}
main()
{
static struct s1 a[]={
{"abcd",a+1},
{"efgh",a+2},
{"ijkl",a}};
struct s1 *p[3];
int i;
for (i=0;i<3;i++)
p[i]=a[i].sip;
printf("1.%s",(*p)->s); /*①*/
printf("*%s",(**p).s); /*②*/
printf("*%s\n",p[0]->s); /*③*/
swap(*p,a);
printf("2.%s",p[0]->s); /*④*/
printf("*%s",(*p)->s); /*⑤*/
printf("*%s\n",(*p)->sip->s); /*⑥*/
swap(p[0],p[0]->sip);
printf("3.%s",(*++p[0]).s); /*⑦*/
printf("*%s\n",p[0]->s); /*⑧*/
printf("4.%s\n",++(*++(*p)->sip).s); /*⑨*/
}
【答】该程序在主函数中定义了一个静态结构体数组,其中三个数组元素构成一个循环链表,每一个数组元素都是一个结构体变量。还定义了一个指向结构体的指针数组,三个元素分别指向结构体数组的三个元素,如图10.1所示。
abcd
ijkl
P[2]
a[0]
P[0]
a[1]
P[1]
a[2]
图10.1 结构体数组a的内存分配
函数swap()有两个入口参数p1及p2,都是指向s1类型的结构体的指针。该函数的功能是交换p1和p2所指结构成员s的值。s是一个指针变量成员,指向一个字符串,因此交换的是地址值。主函数第一次调用swap()时,实参是p[0]的内容和a[0]的地址,p[0]中放着a[1]的地址,调用swap函数交换第一个结构体和第二个结构体中成员s的值。第二次调用swap()时实参是a[1]和a[2]的地址,交换第二个结构体和第三个结构体中成员s的值。在计算表达式(*++p[0]).s之后再计算表达式p[0]->s,这样就先使p[0]指向结构体数组的第三个元素,即第三个结构体,传给printf()函数的都是第三个结构体变量成员s的值。语句⑨中的表达式++(*++(*p)->sip).s是一个比较复杂的表达式,其中*p等价于p[0],在它之前的printf()函数调用的计算中使p[0]指向数组元素a[2]。表达式++(*p)->sip使a[2]中的结构体成员变量sip的值加1,使其指向a[1]。链表的变化情形如图10.2所示。程序输出为:
1.efgh*efgh*efgh
2.abcd*abcd*ijkl
3.abcd*abcd
4.jkl
efgh
jkl
abcd
P[2]
P[0]
a[1]
P[1]
a[2]
图10.2 链表的变化情形
3. 编程题
(1)编写一个程序,从键盘输入10本书的名称和定价并存在一个结构体数组中,从中查找定价最高和最低的书的名称和定价,并输出到屏幕上。
【解】将输入10本书的名称和定价存放在结构体数组a中,循环扫描每个元素的price成员,比较求出最高价和最低价书的下标maxi和mini,最后输出它们的各成员值。程序如下:
/*文件名:exci10_1.cpp*/
VC++6.0
#include
#define N 10
struct book
{
char bname[20];
float price;
};
main()
{
int i,maxi,mini;
float maxp,minp;
struct book a[N];
printf("输入10本书的名称和定价:\n");