结构体测试
一、选择题：
（1）有以下程序段
typedef struct NODE
{ int num; struct NODE *next;
} OLD;
以下叙述中正确的是c
A）以上的说明形式非法 B）NODE是一个结构体类型
C）OLD是一个结构体类型 D）OLD是一个结构体变量
（2）有以下程序
# include
struct STU
{ int num;
float TotalScore; };
void f（struct STU p）
{ struct STU s[2]={{20044,550},{20045,537}};
p.num = s[1].num; p.TotalScore = s[1].TotalScore;
}
main（）
{ struct STU s[2]={{20041,703},{20042,580}};
f（s[0]）;
printf（"%d %3.0f\n", s[0].num, s[0].TotalScore）;
}
程序运行后的输出结果是 d
A）20045 537 B）20044 550 C）20042 580 D）20041 703
（3）有以下程序
# include
struct STU
{ char name[10];
int num; };
void f（char *name, int num）
{ struct STU s[2]={{"SunDan",20044},{"Penghua",20045}};
num = s[0].num;
strcpy（name, s[0].name）;
}
main（）
{ struct STU s[2]={{"YangSan",20041},{"LiSiGuo",20042}},*p;
p=&s[1]; f（p->name, p->num）;
printf（"%s %d\n", p->name, p->num）;
}
程序运行后的输出结果是
A）SunDan 20042 B）SunDan 20044
C）LiSiGuo 20042 D）YangSan 20041
（4）有以下程序
struct STU
{ char name[10]; int num; float TotalScore; };
void f（struct STU *p）
{ struct STU s[2]={{"SunDan",20044,550},{"Penghua",20045,537}}, *q=s;
++p ; ++q; *p=*q;
}
main（）
{ struct STU s[3]={{"YangSan",20041,703},{"LiSiGuo",20042,580}};
f（s）;
printf（"%s %d %3.0f\n", s[1].name, s[1].num, s[1].TotalScore）;
}
程序运行后的输出结果是
A）SunDan 20044 550 B）Penghua 20045 537
C）LiSiGuo 20042 580 D）SunDan 20041 703
（5）若有以下说明和定义
union dt
{
int a; char b; double c;
}data;
以下叙述中错误的是
A）data的每个成员起始地址都相同
B）变量data所占内存字节数与成员c所占字节数相等
C）程序段：data.a=5;printf（"%f\n",data.c）;输出结果为5.000000
D）data可以作为函数的实参
（6）设有如下说明
typedef struct ST
{
long a;
int b;
char c[2];
} NEW;
则下面叙述中正确的是
A）以上的说明形式非法
B）ST是一个结构体类型
C）NEW是一个结构体类型
D）NEW是一个结构体变量
（7）有以下结构体说明和变量定义，如图所示，指针pqr分别指向此链表中三个连续结点。
struct node
{
int data;
struct node *next;
} *p,*q,*r;
现要将q所指结点从链表中删除，同时保持链表的连续,以下不能完成指定操作的语句是
A）p->next=q->next;
B）p->next=p->next->next;
C）p->next=r;
D）p=q->next;
（8）以下对结构体类型变量td的定义中，错误的是
A）typedef struct aa
{
int n;
float m;
}AA;
AA td;
B）struct aa
{
int n;
float m;
} td;
struct aa td;
C）struct
{
int n;
float m;
}aa;
struct aa td;
D）struct
{
int n;
float m;
}td;
（9）有以下说明和定义语句
struct student
{ int age; char num[8];};
struct student stu[3]={{20,"200401"},{21,"200402"},{10\9,"200403"}};
struct student *p=stu;
以下选项中引用结构体变量成员的表达式错误的是
A）（p++）->num B）p->num C）（*p）.num D）stu[3].age
10～12.以下程序的功能是：建立一个带有头结点的单向链表，并将存储在数组中的字符依次转储到链表的各个结点中，请从与下划线处号码对应的一组选若中选择出正确的选项。 #include
stuct node
{ char data; struct node *next;};
（10）CreatList（char *s）
{ struct node *h,*p,*q）;
h=（struct node *）malloc（sizeof（struct node））;
p=q=h;
while（*s!='\0'）
{ p=（struct node *）malloc（sizeof（struct node））;
p->data= （11）;
q->next=p;
q= （12）;
s++;
}
p->next='\0';
return h;
}
main（）
{ char str[]="link list";
struct node *head;
head=CreatList（str）;
...
}
**********************************************************（10）A）char * B）struct node C）struct node* D）char
（11）A）*s B）s C）*s++ D）（*s）++
（12）A）p->next B）p C）s D）s->next
（13）设有以下语句
typedef struct S
{ int g; char h;} T;
则下面叙述中正确的是
A）可用S定义结构体变量 B）可以用T定义结构体变量
C）S是struct类型的变量 D）T是struct S类型的变量
（14）有以下程序
struc STU
{ char name[10];
int num;
};
void f1（struct STU C）
{ struct STU b={“LiSiGuo”,2042};
c=b;
}
void f2（struct STU *C）
{ struct STU b={“SunDan”,2044};
*c=b;
}
main（）
{ struct STU a={“YangSan”,2041},b={“WangYin”,2043};
f1（A）;f2（&B）;
printf（“%d %d\n”,a.num,b.num）;
}
执行后的输出结果是
A）2041 2044 B）2041 2043 C）2042 2044 D）2042 2043
（15）有以下程序
struct STU
{ char name[10];
int num;
int Score;
};
main（）
{ struct STU s[5]={{“YangSan”,20041,703},{“LiSiGuo”,20042,580}, {“wangYin”,20043,680},{“SunDan”,20044,550},
{“Penghua”,20045,537}},*p[5],*t;
int i,j;
for（i=0;i<5;i++）p[i]=&s[i];
for（i=0;i<4;i++）
for（j=i+1;j<5;j++）
if（p[i]->Score>p[j]->Score）
{ t=p[i];p[i]=p[j];p[j]=t;}
printf（“5d%d\n”,s[1].Score,p[1]->Score）;
}
执行后输出结果是
A）550 550 B）680 680 C）580 550 D）580 680
（16）有以下程序
#include
struct NODE{
int num;
struct NODE *next;
};
main（）
{ struct NODE *p,*q,*r;
int sum=0;
p=（struct NODE *）malloc（sizeof（struct NODE））;
q=（struct NODE *）malloc（sizeof（struct NODE））;
r=（struct NODE *）malloc（sizeof（struct NODE））;
p->num=1;q->num=2;r->num=3;
p->next=q;q->next=r;r->next=NULL;
sum+=q->next->num;sum+=p->num;
printf（“%d\n”,sum）;
}
执行后的输出结果是
A） 3 B） 4 C）5 D）6
（17）以下选项中不能正确把c1定义成结构体变量的是
A）typedef struct B）struct color cl
{ int red; { int red;
int green; int green;
int blue; int blue;
} COLOR; };
COLOR cl;
C）struct color D）struct
{ int red; { int red;
int green; int green;
int blue; int blue;
} c l; } c l ;
（18）有以下程序
struct s
{ int x,y;} data[2]={10,100,20,200};
main （）
{ struct s *p=data;
printf（"%d\n",++（p->x））;
}
程序运行后的输出结果是
A）10 B）11 C）20 D）21
（19）有以下结构体说明和变量定义，如图所示，指针p、q、r分别指向一个链表中的三个连续结点。
struct node
{ int data
struct node *next ;
} *p, *q, *r;
（20）设有如下说明
typedef struct
{ int n; char c; double x;}STD;
则以下选项中，能正确定义结构体数组并赋初值的语句是
A）STD tt[2]={{1,'A',62},{2, 'B',75}};
B）STD tt[2]={1,"A",62},2, "B",75};
C）struct tt[2]={{1,'A'},{2, 'B'}};
D）structtt[2]={{1,"A",62.5},{2, "B",75.0}};
（21）有以下程序
main（）
{ union { unsigned int n;
unsigned char c;
}u1;
ul.c=｀A｀;
printf（"%c\n",u1.n）;
}
执行后输出结果是
A）产生语法错 B）随机值 C）A D）65
（22）若要说明一个类型名STP，使得定义语句STP s等价于char *s，以下选项中正确的是
A）typedef STP char *s; B）typedef *char STP;
C）typedef stp *char; D）typedef char* STP;
（23）设有如下定义
struct ss
{ char name[10];
int age;
char sex;
}std[3],*p=std;
下面各输入语句中错误的是
A）scanf（"%d",&（*p）.age）; B）scanf（"%s",&https://www.wendangku.net/doc/fc14672205.html,）; C）scanf（"%c",&std[0].sex） D）scanf（"%c",&（p->sex））;
（24）有以下程序
struct STU
{ char num[10]; float score[3]; };
main（）
{ struct stu s[3]={{“20021”,90,95,85},
{“20022”,95,80,75},
{“20023”,100,95,90}},*p=s;
int i; float sum=0;
for（i=0;i<3,i++）
sum=sum+p->score[i];
printf（“%6.2f\n”,sum）;
}
程序运行后的输出结果是
A）260.00 B）270.00 C）280.00 D）285.00
（25）设有如下定义：
struck sk
{ int a;
float b;
}data;
int *p;
若要使P指向data中的a域，正确的赋值语句是
A）p=&a; B）p=data.a; C）p=&data.a; D）*p=data.a;
（26）有以下程序
#include
struct NODE
{ int num; struct NODE *next; };
main（）
{ struct NODE *p,*Q,*R;
p=（struct NODE*）malloc（sizeof（struct NODE））;
q=（struct NODE*）malloc（sizeof（struct NODE））;
r=（struct NODE*）malloc（sizeof（struct NODE））;
p->num=10; q->num=20; r->num=30;
p->next=q;q->next=r;
printf（“%d\n”,p->num+q->next->num）;
}
程序运行后的输出结果是
A）10 B）20 C）30 D）40
（27）若有以下说明和定义
typedef int *INTEGER;
INTEGER p,*q;
以下叙述正确的是
A）P是int型变量 B）p是基类型为int的指针变量
C）q是基类型为int的指针变量 D）程序中可用INTEGER代替int类型名
（28）若有下面的说明和定义：
struct test
{ int ml; char m2; float m3;
union uu {char ul[5]; int u2[2];} ua;
} myaa;
则sizeof（struct test ）的值是
A）12 B）16 C）14 D）9
（29）若以下定义:
struct link
{ int data;
struck link *next;
}a,b,c,*p,*q;
且变量a和b之间已有如下图所示的链表结构:
a b
data next data next
↑p
c
data next
↑q
指针p指向变量a,q指向变量c。则能够把c插入到a和b 之间并形成新的链表的语句组是:
A） a.next=c; c.next=b; B）p.next=q; q.next=p.next;
C）p->next=&c; q->next=p->next; D）（*p）.next=q; （*q）.next=&b;
现要将q和r所指结点的先后位置交换，同时要保持链表的连续，以下错误的程序段是 A）r->next=q; q->next=r->next; p->next=r;
B）q->next=r->next; p->next=r; r->next=q;
C）p->next=r; q->next=r->next; r->next=q;
D）q->next=r->next; r->next=q; p->next=r;
（30）设有以下说明语句
typedef struct
{ int n;
char ch[8];
}PER;
则下面叙述中正确的是
A）PER 是结构体变量名 B）PER是结构体类型名
C）typedef struct 是结构体类型 D）struct 是结构体类型名
（31）以下各选项企图说明一种新的类型名，其中正确的是
A）typedef v1 int; B）typedef v2=int;
C）typedefv1 int v3; D）typedef v4: int;
（32）以下程序的输出结果是
struct HAR
{ int x, y; struct HAR *p;} h[2];
main（）
{ h[0],x=1;h[0];y=2;
h[1],x=3;h[1];y=4;
h[0],p=&h[1],p=h;
printf（“%d %d \n”,（h[0],p）->x,（h[1],p）->y）;
}
A）12 B）23 C）14 D）32
（33）以下程序的输出结果是
union myun
{ struct
{ int x, y, z; } u;
int k;
} a;
main（）
{ a.u.x=4; a.u.y=5; a.u.z=6;
a.k=0;
printf（%d\n”,a.u.x）;
}
A） 4 B） 5 C）6 D）0
（34）设有以下说明语句
struct ex
{ int x ; float y; char z ;} example;
则下面的叙述中不正确的是
A）struct结构体类型的关键字 B）example是结构体类型名
C）x,y,z都是结构体成员名 D）struct ex是结构体类型
（35）以下程序的输出是
A）10 B）11 C）51 D）60
struct st
{ int x; int *y;} *p;
int dt[4]={ 10,20,30,40 };
struct st aa[4]={ 50,&dt[0],60,&dt[0],60,&dt[0],60,&dt[0],};
main（）
{ p=aa;
printf（“%d\n”,++（p->x））;
}
（36）假定建立了以下链表结构，指针p、q分别指向如图所示的结点，则以下可以将q 所指结点从链表中删除并释放该结点的语句组是
A）free（q）; p->next=q->next;
B）（*p）.next=（*q）.next; free（q）;
C）q=（*q）.next; （*p）.next=q; free（q）;
D）q=q->next; p->next=q; p=p->next; free（p）
（37）有如下定义
struct person{char name[9]; int age;};
strict person class[10]={“Johu”,17,
“Paul”,19
“Mary”,18,
“Adam16,};
根据上述定义，能输出字母M的语句是
A）prinft（“%c\n”,class[3].mane）;
B）pfintf（“%c\n”,class[3].name[1]）;
C）prinft（“%c\n”,class[2].name[1]）;
D）printf（“%^c\n”,class[2].name[0]）;
（38）以下对结构体类型变量的定义中，不正确的是
A）typedef struct aa B）#define AA struct aa
{ int n; AA {int n;
float m; float m;
}AA; }td1;
AA td1;
C）struct D）struct
{ int n; { int n;
float m; float m;
}aa; }td1;
stuct aa td1;
（39）若已建立如下图所示的单向链表结构，
在该链表结构中，指针p、s分别指向图中所示结点，则不能将s所指的结点插入到链表末尾仍构成单向链表的语句组是
A）p =p->next; s->next=p; p->next=s;
B）p =p->next; s->next=p->next; p->next=s;
C）s->next=NULL; p=p->next; p->next=s;
D）p=（*p）.next; （*s）.next=（*p）.next; （*p）.next=s;
（40）下列程序的输出结果是
A） 5 B） 6 C）7 D）8
struct abc
{ int a, b, c; };
main（）
{ struct abc s[2]={{1,2,3},{4,5,6}}; int t;
t=s[0],a+s[1],b;
printf（"%d \n",t）;
}
（41）有以下结构体说明和变量的定义,且如下图所示指针p指向变量a,指针q指向变量b。则不能把结点b连接到结点a之后的语句是
A） a.next=q; B）p.next=&b;
C）p->next=&b; D）（*p）.next=q;
struct node
{ char data;
struct node *next;
{ a,b,*p=&a,*q=&b;
data next data next
（42）变量a所占内存字节数是
A） 4 B） 5 C）6 D）8
union U
{ char st[4];
int i;
long l;
};
struct A
{ int c;
union U u;
}a;
（43）以下选项中，能定义s为合法的结构体变量的是A）typedef struct abc B）struct
{ double a；{ double a；
char b[10]；char b[10]；
} s；} s；
C）struct ABC D）typedef ABC
{ double a；{ double a；
char b[10]；char b[10]；
} }
ABC s；ABC s；
（44）以下程序的输出结果是
A） 2 B） 1 C）0 D）不确定
main（）
{ union { char i[2];
int k;
}r;
r.i[0]=2; r.i[1]=0;
printf{“%d\n”,r.k};
}
（45）设有以下定义或语句，则输出的结果是（指针变量占两个字节） A）20 B）16 C）14 D）12
struct date
{ long *cat;
struct date *next;
double dog;
}too;
printf（“%d\n”,sizeof（too））;
（46）有以下程序
#include
struct stu
{ int num;
char name[10];
int age;
};
void fun（struct stu *p）
{ printf（"%s\n",（*p）.name）; }
main（）
{
struct stu students[3]={ {9801,"Zhang",20},
{9802,"Wang",19},
{9803,"Zhao",18} };
fun（students+2）;
}
输出结果是
A）Zhang B）Zhao C）Wang D）18
（47）设有以下说明和定义:
typedef union
{ long i; int k[5]; char c; }DA TE;
struct date
{ int cat; DA TE cow; double dog; } too;
DA TE max;
则下列语句的执行结果是
printf （"%d",sizeof （struct date ）+sizeof（max））;
A）26 B）30 C）18 D）8
（48）设有如下定义:
struct sk
{int a;float b;}data,*p;
若有p=&data;，则对data中的a域的正确引用是
A）（*p）.data.a B）（*p）.a C）p->data.a D）p.data.a
（49）若程序中有下面的说明和定义
struct abc
{int x;char y;}
struct abc s1,s2;
则会发生的情况是
A）编译进错 B）程序将顺利编译`连接`执行
C）能顺利通过编译`连接`但不能执行 D）能顺利通过编译`但连接出错
（50）若有下面的说明和定义，则sizeof（struct aa）的值是
struct aa
{ int r1;double r2; float r3;
union uu{char u1[5]; long u2[2]; } ua;
} mya;
A）30 B）29 C）24 D）22
（51）字符'0'的ASCII码的十进制数为48,且数组的第0个元素在低位,则以下程序的输出结果是
#include
main（）
{ union { int i[2]; long k; char c[4]; }r,*s=&r;
s->i[0]=0x39;
s->i[1]=0x38;
printf（"%c\n",s->c[0]）}
A）39 B）9 C）38 D）8
（52）设有以下定义:
typedef union { long i;int k[5];char c;}DA TE;
struct date { int cat;DA TE cow;double dog;}too;
DA TE max;
则下列语句的执行结果是
printf（"%d",sizeof（struct date）+sizeof（max））;
A）25 B）30 C）18 D）8
（53）根据下面的定义，能打印出字母M的语句是
A）printf（"%c\n",class[3].name）;
D）printf（"%c\n",class[2].name[0]）;
B）printf（"%c\n",class[3].name[1]）;
C）printf（"%c\n",class[2].name[1]）;
struct person { char name[9]; int age;};
struct person class[10]={"John",17,
"Paul",19,
"Mary",18,
"Adam",16};
（54）下面程序的输出是
A）0 B） 1 C） 3 D）6
main（）
{ struct cmplx { int x; int y; } cnum[2]={1,3,
2,7};
printf（"%d\n",cnum[0].y /cnum[0].x * cnum[1].x）;}
（55）已知字符0的ASCII码为十六进制的30，下面程序的输出是
A） 6 B）9 C）0 D）3
main（）
{ union { unsigned char c;
unsigned int i[4];
} z;
z.i[0]=0x39;
z.i[1]=0x36;
printf（"%c\n",z.c）;}
（56）下面程序的输出是
A）32 B）16 C）8 D）24
typedef union { long x[2];
int y[4];
char z[8];
} MYTYPE;
MYTYPE them;
main（）
{ printf（"%d\n", sizeof（them））;}
（57）若已建立下面的链表结构，指针p、s分别指向图中所示的结点，则不能将s所指的结点插入到链表末尾的语句组是
A）s->next=NULL; p=p->next; p->next=s;
B）p=p->next; s->next=p->next; p->next=s;
C）p=p->next; s->next=p; p->next=s;
D）p=（*p）.next; （*s）.next=（*p）.next; （*p）.next=s;
（58）下面程序的输出结果为
struct st
{ int x;
int *y;
} *p;
int dt[4]={10,20,30,40};
struct st aa[4]={ 50,&dt[0],60,&dt[1],
70,&dt[2],80,&dt[3] };
main（）
{ p=aa;
printf（"%d\n", ++p->x ）;
printf（"%d\n", （++p）->x）;
printf（"%d\n", ++（*p->y））;
}
A）10 B）50 C）51 D）60
20 60 60 70
20 21 21 31
（59）有以下程序：
#include
union pw
{ int i; char ch[2]; } a;
main（）
{ a.ch[0]=13; a.ch[1]=0; printf（"%d\n",a.i）; }
程序的输出结果是（注意：ch[0]在低字节，ch[1]在高字节。）
A）13 B）14 C）208 D）209
（60）设有以下语句：
struct st {int n; struct st *next;};
static struct st a[3]={5,&a[1],7,&a[2],9,'\0'},*p;
p=&a[0];
则表达式【60】的值是6。
A）p + + ->n B）p->n + + C）（*p）.n + + D）+ + p->n 二、填空题:
（1）以下程序运行后的输出结果是【1】。
struct NODE
{ int num; struct NODE *next;
} ;
main（）
{ struct NODE s[3]={{1, '\0'},{2, '\0'},{3, '\0'}}, *p, *q, *r;
int sum=0;
s[0].next=s+1; s[1].next=s+2; s[2].next=s;
p=s; q=p->next; r=q->next;
sum+=q->next->num; sum+=r->next->next->num;
printf（"%d\n", sum）;
}
（2）以下程序运行后的输出结果是【2】。
struct NODE
{ int k;
struct NODE *link;
};
main（）
{
struct NODE m[5],*p=m,*q=m+4;
int i=0;
while（p!=q）
{ p->k=++i; p++;
q->k=i++; q--;
}
q->k=i;
for（i=0;i<5;i++）
printf（"%d",m[i].k）;
printf（"\n"）;
}
（3）以下程序的运行结果是【3】
# include
typedef struct student{
char name[10];
long sno;
float score;
}STU;
main（）
{ STU
a={“zhangsan”,2001,95},b={“Shangxian”,2002,90},c={“Anhua”,2003,95},d,*p=&d;
d=a;
if（strcmp（https://www.wendangku.net/doc/fc14672205.html,,https://www.wendangku.net/doc/fc14672205.html,）>0）d=b;
if（strcmp（https://www.wendangku.net/doc/fc14672205.html,,https://www.wendangku.net/doc/fc14672205.html,）>0）d=c;
printf（“%ld%s\n”,d.sno,p->name）;
}
（4）已有定义如下：
struct node
{ int data;
struct node *next;|
} *p;
以下语句调用malloc函数，使指针p指向一个具有struct node类型的动态存储空间。请填空。
p=（struct node *）malloc（【4】）;
（5）设有以下定义
struct ss
{ int info;struct ss *link;}x,y,z;
且已建立如下图所示链表结构：请写出删除点y的赋值语句【5】。
（6）下面程序的运行结果是：[6] 。
typedef union student
{ char name[10];
long sno;
char sex;
float score[4];
}STU;
main（）
{ STU a[5];
printf（“%d\n”,sizeof（a））;
}
（7）以下定义的结构体类型拟包含两个成员,其中成员变量info用来存入整形数据;成员变量link是指向自身结构体的指针.请将定义补充完整。
struct node
{int info;
【7】link;
}
（8）以下程序段用于构成一个简单的单向链表，请填空。
struct STRU
{ int x, y ;
float rate;
【8】p;
} a, b;
a.x=0; a.y=0; a.rate=0; a.p=&b;
b.x=0; b.y=0; b.rate=0; b.p=NULL;
（9）若有如下结构体说明：
struct STRU
{ int a, b ; char c; double d:
struct STRU p1,p2;
};
请填空，以完成对t数组的定义，t数组的每个元素为该结构体类型
【9】t[20];
（10）以下程序用来输出结构体变量ex所占存储单元的字节数，请填空。
struct st
{ char name[20]; double score; };
main（）
{ struct st ex;
printf（“ex size: %d\n”,sizeof（【10】））;
}
（11）设有以下结构类型说明和变量定义，则变量a在内存所占字节数是[11] 。
Struct stud
{ char num[6];
int s[4];
double ave;
} a,*p;
（12）有以下定义和语句，则sizeof（a）的值是【12】,而sizeof（a.share）的值是【13】 struct date{ int day;
int month;
int year;
union{int share1
float share2;
}share;
}a;
（13）若以下定义和语句,则sizeof（a）的值是【14】,而sizeof（b）的值是【15】struct { int day; char mouth; int year;} a, *b;
b=&a;
（14）变量root有如图所示有存储结构,其中sp是指向字符串的指针域,next 是指向该结构的指针域,data用以存放整型数. 请填空, 完成此结构的类型说明和变量root的定义
sp next data
┌─┬─┬─┐
root││││
└─┴─┴─┘
struct list
{ char *sp;
【16】;
【17】;
}root;
（15）有以下说明定义和语句，可用a.day引用结构体成员day, 请写出引用结构体成员a.day的其它两种形式【18】、【19】。
struct{int day;char mouth;int year;}a,*b; b=&a;
（16）现有如图所示的存储结构，每个结点含两个域，data是指向字符串的指针域，next 是指向结点的指针域。请填空完成此结构的类型定义和说明。
struct link
{【20】; 【21】;} *head;
（17）以下函数creat用来建立一个带头结点的单向链表，新产生的结点总是插在链表的末尾。单向链表的头指针作为函数值返回.请填空: