练习题10及参考答案.doc

(完整版)练习题10及参考答案
窗体顶部
练习题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 〈stdio.h>
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 <stdio。h〉
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 〈stdio。h〉
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 〈stdio。h〉
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 〈stdio。h>
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 〈stdio.h〉
＃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 〈stdio。h>
#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 <stdio.h>
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 <stdio.h>
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 〈stdio.h〉
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 〈stdio。h>
＃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 〈stdio。h〉
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 〈stdio。h〉
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 〈stdio。h>
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
3。bcd
4。bcd
5.efgh
（10）以下程序的运行结果是      。
#include <stdio.h>
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

efgh

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］

a[0］

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 <stdio.h〉
#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");
    for （i=0;i〈N；i++）
    {
        printf（"第%d本书：",i+1）；
        scanf("％s"，&a［i].bname);
        scanf（"%f”,＆a［i].price）;
    ｝
    maxp=minp=a［0].price；
    for （i=1；i〈N;i++）
    {
        if (maxp〈a［i]。price)
        ｛
            maxi=i；
            maxp=a[i］。price;
        }
        if （minp>a［i]。price）
        ｛
            mini=i;
            minp=a[i］.price;
        }
    ｝
    printf("最高价书：%s,%g\n"，a［maxi].bname,a［maxi]。price）;
    printf(”最低价书:%s,%g\n"，a［mini]。bname，a[mini］。price）;
｝
(2）一个人事管理程序的对象为教师和学生，人事档案包均如下信息：
· 编号
· 姓名
· 年龄
· 分类—教师或学生
· 教师教的课程名（1门）
· 教师职称
· 学生的入学成绩（3门课）
试用C语言定义一结构体类型，声明上述信息.假定人事档案已存放在person[]的数组中，试编写一打印输出全部人员档案的程序。
【解】定义人事档案结构体类型如下：
typedef struct node
｛
    int no；                             /＊编号*/
    char name[10］;                      /＊姓名*/
    int age;                            /＊年龄*/
    char type[2］;                       /＊分类:t—教师 s-学生＊/
    union                               /*共用体＊/
    {
        struct
        ｛
            char course［20］;            /*课程*/
            char prof[10］;              /＊职称＊/
        } tech；
        struct
        {
            int deg1，deg2，deg3；        /*3门课成绩＊/
        ｝ stud;
    ｝ body;
｝ document；
打印输出全部人员档案的函数如下：
/*文件名：exci10_2.cpp*/
VC++6。0
void func(int n)                        /＊n为人员个数*/
｛
    document person［N]；
    int i;
    printf(”编号  姓名  年龄 分类  授课名  职称  成绩1  成绩2  成绩3\n");
    for （i=0；i〈n;i++）
    ｛
        if (person［i］.type［0]==’t')
            printf（”%3d％10s％6d％6s%20s%10s\n"，person［i].no,
                person［i］.name，person［i］.age，”教师",
                person[i]。body。tech.course,
                person[i］。body。tech.prof）；
        else if （person[i］。type[0]=='s’）
            printf("%3d％10s％6d%20d％6d%6d\n"，person[i]。no，
                person［i]。name,person［i]。age，"学生",
                person［i].body。stud。deg1,person［i］.body。stud.deg2,
                person[i]。body。stud.deg3）；
    ｝
    printf（”\n");
｝
（3)有两个递增有序表，分别用单链表存放，在不破坏原有序表的前提下,将两个有序表合并为一个有序表.
【解】先创建要生成的有序表的头结点*headc,用pa、pb分别扫描有序表A、B.比较＊pa、*pb的data域，将较小者复制后链接到headc链表的最后，相同时两个均复制并链接到headc链表的最后。将两个有序表中剩余的结点复制后链接到headc链表的最后。程序如下：
/*文件名：exci10_3。cpp＊/
VC++6。0
#include <stdio。h〉
＃include 〈malloc。h〉
ListNode ＊comblist（ListNode *heada，ListNode *headb)
｛
    ListNode *headc，＊s,*r,*pa=heada—〉next，*pb=headb—>next；
    headc=(ListNode ＊)malloc(sizeof（ListNode）)；     /＊创建表头结点＊/
    r=headc;                    /*r始终指向新生成单链表的最后一个结点＊/
    while (pa！=NULL &＆ pb！=NULL）
    ｛
        if (pa-〉data〈pb->data）
        ｛
            s=（ListNode *)malloc（sizeof(ListNode))；     /＊创建新结点*/
            s—>data=pa—>data；r-〉next=s;r=s;
            pa=pa-〉next；
        }
        else if （pa—〉data〉pb—>data)
        {
            s=（ListNode *)malloc（sizeof（ListNode));     /＊创建新结点*/
            s—〉data=pb—〉data；r->next=s；r=s;
            pb=pb—>next；
        }
        else
        {
            s=(ListNode *)malloc(sizeof（ListNode));     /*创建新结点＊/
            s—>data=pa-〉data；r-〉next=s；pa=pa—〉next；r=s；
            s=(ListNode ＊）malloc(sizeof（ListNode）)；     /＊创建新结点＊/
            s—>data=pb—〉data;r—〉next=s;pb=pb—>next；r=s;
        ｝
    ｝
    if (pa==NULL）
        pa=pb;
    while (pa！=NULL)
    ｛
        s=(ListNode *）malloc(sizeof(ListNode))；         /*创建新结点＊/
        s—〉data=pa—>data；r—〉next=s；pa=pa—>next；r=s；
    ｝
    r—>next=NULL;
    return headc；
｝
main()
{
    ListNode ＊ha,＊hb,＊hc；
    ha=createlist(）;                    /＊创建A有序表＊/
    hb=createlist(）；                    /*创建B有序表＊/
    printf("A有序表：”)；displist（ha)；
    printf（"B有序表:”）;displist（hb）；
    hc=comblist（ha,hb)；
    printf（”合并结果：”);displist(hc);
}
本程序中使用到的ListNode类型定义和createlist(）、displist(）等函数设计参见《C程序设计教程》10.4。2节.程序运行结果：
输入结点值：1 3 5↙
输入结点值：2 4 6↙
A有序表:1 3 5
B有序表:2 4 6
合并结果:1 2 3 4 5 6
（4)编写一个程序，将一个长整数分离成两个整数，例如，0x123456，分离成0x12和0x3456两个数.
【解】将这个长整数以long型变量存放,利用一个共用体变量分离为两个短整数。程序如下：
/＊文件名:exci10_4。cpp＊/
VC++6.0
＃include 〈stdio.h>
void parts(unsigned long num，unsigned short *low,unsigned short ＊high)
{
    union
    {
        unsigned short part［2]；
        unsigned long w;
    } n；
    n。w=num；
    ＊high=n。part[1］；
    ＊low=n.part［0］;
}
main（）
｛
    unsigned long x;
    unsigned short m,n;
    printf("输入x：")；
    scanf("％x”,&x)；
    parts(x,&m，＆n）;
    printf(”高位％x,低位％x\n”,n，m）;
｝
程序运行结果：
输入x:12345678↙
高位1234,低位5678
（5）利用结构体类型编写一个程序实现以下功能：
① 根据输入的日期（年月日),求出这天是该年的第几天；
② 根据输入的年份和天数，求出对应的日期。
【解】用daytab数组存放非闰年和闰年各月份的天数.对于year年，判断其是否为闰年的条件为：
leap=(year％4==0 ＆＆ year％100！=0 ｜| year％400==0)；
用一个结构体类型date的变量dt存放用户输入的日期。程序如下:
/*文件名：exci10_5.cpp*/
VC++6。0
＃include 〈stdio。h>
int daytab［2]［13］={｛0，31,28，31,30,31,30,31，31,30，31,30,31｝，
                {0,31，29，31，30，31,30,31，31,30,31，30，31｝｝;
struct date
｛
    int year；
    int month；
    int day;
｝ dt;
int day_of_year（int year,int month，int day）     /*求指定日期的天数*/
{
    int i,leap;
    leap=（year％4==0 ＆& year%100!=0 |｜ year％400==0）；
    for (i=1;i〈month;i++)
        day+=daytab[leap］[i］;
    return day;
}
void month_day(int year,int yearday,int *pmonth,int *pday）
                    /＊由年份year和天数yearday求月份pmonth和日号pday*/
｛
    int i，leap；
    leap=（year％4==0 && year％100！=0 || year％400==0)；
    for (i=1;yearday〉daytab[leap]［i］;i++)
        yearday-=daytab［leap][i];
    *pmonth=i;
    ＊pday=yearday;
}
main()
｛
    int k,days;
    while (1）           /*用户选择：起到菜单的作用＊/
    ｛
        printf（"1：日期->天数 2：年，天