结构体和共用体
第十一章结构体和共用体
11．1 本章基本知识结构
11．2 知识难点解析
1．结构体与共用体变量在计算机中占用多少内存？
[解答] 结构体变量所占的内存长度等于所有各成员的长度之和，每个成员分别占有自己的内存单元；共用体变量所占的内存长度等于最长的成员的长度。
2．结构体和共用体的有几种不同的引用方法？
[解答] 结构体和共用体一样，有两种引用办法，一种是采用成员（分量）运算符“.”；还有一种是采用指针的办法。下面以结构体为例说明这两种不同的引用的方法。
struct stu
{int num;
char name[10];
int age;
} zhangsan, *lisi;
要访问学生zhangsan年龄的办法有两种：zhangsan.age 或者（&zhangsan）
—>age；
要访问学生lisi年龄的办法也有两种：(*lisi).age 或者lisi—>age。
11．3 习题
1．选择题
(1)．以下程序运行的输出结果是( )。
main()
{union {char i[2];
int m;
}r;
r.i[0]=2;r.i[1]=0;
printf("%d\n",r.m);
}
A.2
B.1
C.0
D.不确定
[分析、解答] 答案为A。本题涉及共用体的概念。字符数组i[2]与整型变量m使用同一内存单元。M占用2个字节，高字节对应i[1],低字节对应i[0],所以答案为A。
(2)．有以下程序输出结果是( )。
#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
[分析、解答]答案为B。在main函数中，定义结构体类型数组student[3],并赋初值。即student[0]={9801，〞zhang〞,20},
student[1]={9802, 〞wang〞,19},
student[2]={9803, 〞zhao〞,18},
调用子函数fun,实参“student+2”为student[2]的首地址，则p指向student[2]的首地址，(*p).name即“zhao”。
(3)．有下列程序输出结果是( )。
#include
main()
{union
{int k;
char i[2];
}*a,b;
a=&b;
a->i[0]=0x39;
a->i[1]=0x38;
printf("%x\n",a->k);
}
A.3839
B.3938
C.380039
D.390038
[分析、解答]答案为A。题中a是指向共用体类型变量b的指针变量，整型变量k与字符数组i[2]共用。一个存储单元，k的高位字节对应i[1],k的低位字节对应i[0].“0x39”表示十六进制数的39。“%x”表示十六进制的格式输出。
(4)．设有如下定义：
struct num
{ 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
[分析、解答]答案为B。p指向结构体类型变量data的首地址，*p即代表data,因此答案为B。
(5)．若有下面的说明和定义，则sizeof(struct aaa)的值是( )。
struct aaa
{ int r1；
double r2；
float r3；
union uuu
{ char u1[5]；
long u2[2]；
}ua；
}mya；
A.30
B.29
C.24
D.22
[分析、解答] 答案为D。这是结构体套用共用体的形式，共用体的长度为8。sizeof 为长度运算符。sizeof(struct aaa)等价于sizeof(mya)=2+8+4+8=22。
(6)．设有以下定义
typedef union
{ long m；
int k[5]；
char ch；
} DATE；
struct date
{ int cat；
DATE cow；
double dog；
} too；
DATE max；
则语句printf(〞%d〞,sizeof(struct date)+sizeof(max)))的执行结果是( )。
A.25
B.30
C.18
D.8
[分析、解答]答案为B。本题用typedef声明新的类型名“DATE”来代替已有的类型名union。sizeof是长度运算符。max,cow都是共用体类型，长度为“int k[5]”的长度，即10。所以：sizeof (struct date)+sizeof(max)=(2+10+8)+10=30。
(7)．字符ˊ0ˊ的ASCII码的十进制数为48，且数组的第0个元素在低位，则
以下程序的输出结果是( )。
#include
main()
{ union
{ int i[2]；
long m；
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
[分析、解答]：答案为B。“0x39”代表十六进制的39，即十进制的57，c[0] 对应i[0]的低字节，由于十进制的57在内存中不超过8个二进制位(大于255不可)，所以对应c[0]的就是57。而字符0的ASCII码的十进制数为48,57就对应字符‘9’。因此答案为B。
(8)．若已建立下面的链表结构，指针p,s分别指向图中所示的结点，则不能将
所指的结点插入到链表末尾的语句组是( )。
data next
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；
[分析、解答]：答案为C。s->next=p；p->next=s使得p，s所指的节点构成了环路而不是链表。
(9)．根据下面的定义，能打出字母M的语句是( )。
struct student
{ char name[9]；
int age；
}
struct student class[10]={ 〞John〞,17, 〞Paul〞,19, 〞Mary〞,18,
〞Adam〞,16}；
A.printf(〞%c\n〞,class[3].name)；
B.printf(〞%c\n〞,class[3].name[1])；
C.printf(〞%c\n〞,class[2].name[1])；
D.printf(〞%c\n〞,class[2].name[0]；
[分析、解答]：答案为 D。本题的要点是结构体成员的表示。class[10]是结构体类型的数组，每个元素的长度是11，前9 个字符型的放名字，后两个整型的放年龄。A是指“Adam”。B是指d。C 是指a。D指M。
(10). 下列程序的执行结果为( )。
struct str
{ char *s;
int i;
struct str *sip;
}
main()
{ static struct str a[]={{"abcd",1,a+1},{"efgh",2,a+2},{"ijkl",3,a}};
struct str *p=a;int i=0;
printf("%s%s%s",a[0].s,p->s,a[2].sip->s);
printf("%d%d",i+2,--a[i].i);
printf("%c\n",++a[i].s[3]);
}
A.abcd abcd abcd 2 0 e
B.abcd efgh ijkl 2 0 e
C.abcd abcd ijkl 2 0 e
D.abcd abcd abcd 2 1 e
[分析、解答]：答案为 A。
(11). 下面程序的输出结果为( )。
struct st
{ int x;
int *y;
} *p;
int data[4]={10,20,30,40};
struct st aa[4]={50,&data[0],60,&data[1],70,&data[2],80,&data[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
[分析、解答]答案为C。本题的说明中定义了一个名为st的结构体。它由两个成员组成：一个是整型变量x；一个是指针变量。在定义的同时说明了一个指向这一结构类型的指针变量p.数组每个元素是一个含有两个成员的struct st型的结构，并赋有初值。在main函数中执行p=aa；语句后，p指向了数值的首地址，它们之间的关系如图所示:
这里需要注意运算符的优先级，对于题目中涉及的运算符（）、—>、++、*，其中括号最优先，其次是指向结构体成员运算符—>，下来是自增运算符++和指针运算符*，它们属于同级运算，其结合方向是“自右至左”。
参照上图可知，第一条printf语句的输出项++p→x是先找出p→（其值为50），再将其值自增1，取增值后的值，故输出51。
第二条printf语句的输出项为(++p)→x，它表示先将指针p自增1，指向aa数组的第二个元素aa[1]，然后取其第一个成员aa[1].x的值。故输出为60。
第三次的输出项为++(*p→y)。此时p已指向aa[1]，因此输出项等价于++（data[1]）,先取出data[1]的值（20），再将其增1，故输出21。
由此可见，答案C正确。
(12). 设有以下语句：
struct student{int n;struct student *next;};
static struct student a[3]={5,&a[1],7,&a[2],9,'\0'},*p;
p=&a[0];
则表达式( )的值是6。
A.p++->n
B.p->n++
C.(*p).n++
D.++p->n
[分析、解答]：答案为 D。
(13). 下面程序的输出是( )。
main()
{ enum team{a,b=4,c,d=c+10};
printf("%d %d %d %d\n",a,b,c,d);
}
A.0 1 2 3
B.0 4 0 10
C.0 4 5 15
D.1 4 5 15
[分析、解答]答案为C。根据C语言的语法规定，一旦定义了一个枚举类型，编译系统将按顺序为每个枚举元素分配一个对应的序号，序号值从0开始，后续元素的序号顺序加1。此外，C语言也允许在定义枚举类型的同时人为地指定枚举元素的序号值，凡没有指定序号值的元素则在前一元素序号的基础上顺序加1。由此可知，题中第一个枚举元素a的序号值为0；第二个元素b的序号值为4；第三个元素c的序号值为5；第四个元素d的序号值为15。故本程序的输出结果应当是答案C。
(14). 下面程序的输出是( )。
main()
{ struct cmplx{int x;int y;}
num[2]={1,3,2,7};
printf("%d\n",num[0].y/num[0].x*num[1].x);
}
A.0
B.1
C.3
D.6
[分析、解答] 答案为D。题中定义了结构体类型数组num，程序中已给出：num[0].x的值是1，num[0].y的值是3，num[1].x的值是2.由于C语言中的运算符“/”和“*”优先级相同，且运算顺序从左至右，因此该程序应输出结果是6。
(15). 下面程序的输出是( )。
typedef union { long x[2];
int y[4];
char z[8];
} MYTYPE;
MYTYPE them;
main()
{ printf("%d\n",sizeof(them));
}
A.32
B.16
C.8
D.24
[分析、解答] 答案为C。此题参考知识难点解析1。
2．填空题
(1)．有以下定义和语句，则sizeof(a)的值是【1】，而sizeof(a.share)的值是【2】。
struct date
{ int day；
int month；
int year；
union
{ int share1；
float share2；
}share；
} a；
[分析、解答] 答案为【1】10 【2】4
本题的知识点是考察结构体、共用体变量占内存大小。具体参考知识难点解析1
(2)．若有以下说明和定义语句，则变量w在内存中所占字节数________。
{ float x,y；
char c[6]；
}；
struct st
{ union aa v；
float w[5]；
double ave；
} w；
[分析、解答] 答案为34。W的占内存大小sizeof(v)+sizeof(w[5])+sizeof(ave)=
6+4×5+8=34。
(3)．有以下说明定义语句，可用a.day引用结构体成员day,请写出引用结构体成员a.day 的其它两种形式【 1 】【 2 】。
{ int day；
char mouth；
int year；
} a,*b；
b=&a；
[分析、解答] 答案为【1】(*b).day 【2】b->day
具体参考知识难点解析2。
(4)．为了建立如图所示的存储结构（即每个结点含两个域，data是数据域，next是指向该
结构的指针域，data用以存放整型数）请填空。
data next
struct link {char data；( 【 1 】 )}node；
[分析、解答] 答案为【1】struct link *next
本题的知识点是链表。
(5)．变量root有如图所示的存储结构，其中sp是指向字符串的指针的指针域，nextp是
指向该结构的指针域，data用以存放整型数。请填空，完成此结构的类型说明和变量root的定义。
root
struct list
{
char *sp；
( 【1】 )
( 【2】)
[分析、解答] 答案为【1】struct list *nextp 【2】int data
本题的知识点是链表。
(6)．下列程序的执行结果为_______。
main()
{ union bt
{ int k;
char c[2];
}a;
a.k=-7;
printf("%o,%o\n",a.c[0],a.c[1]);
}
[分析、解答] 答案为177771,177777
本题的知识点是共用体的各成员共用一段内存。
(7).若有以下的说明、定义和语句，则输出结果为_______（已知字母A的十进制数为65）。
main()
{ union un
{ int a;
char c[2];
} w;
w.c[0]='A';w.c[1]='a';
printf("%o\n",w.a);
}
[分析、解答] 答案为60501。
本题考察知识点还是共用体的各成员共用一段内存。W占2个字节的空间，第一个字节w.c[0]='A'，即65，第二个字节w.c[1]='a'，即97，整个2个字节的空间里分布的两进制数值是0110000101000001 ，八进制即60501。
(8). 程序运行的结果是________。
main()
{ union exam
{ struct
{ int x;
int y;
} in;
int a;
int b;
}em;
em.a=1;em.b=2;em.in.x=em.a*em.b;em.in.y=em.a+em.b;
printf("%d,%d\n",em.in.x,em.in.y);
}
[分析、解答] 答案为4,8。
(9).下面程序的输出结果是________。
{ int a;
int *b;
}
main()
{ struct em s[4],*p;int n=1,i;
for(i=0;i<4;i++)
{ s[i].a=n;
s[i].b=&s[i].a;
n=n+2;
}
p=&s[0];
printf("%d,%d\n",++(*p->b),*(s+2)->b);
}
[分析、解答] 答案为2 5
（10）.下面程序的输出结果是________。
#include
union un
{ int i;
char ch[2];
} a;
main()
{ a.ch[0]=13;
a.ch[1]=0;
printf("%d\n",a.i);
}
[分析、解答] 答案为13
(11). 若有以下的说明和语句，已知int类型占两个字节，则以下的输出结果为_______。
main()
{ struct st
{ char a[10];
int b;
double c;
};
printf("%d\n",sizeof(struct st));
}
[分析、解答] 答案为20。
本题的知识点是考察结构体、共用体变量占内存大小。具体参考知识难点解析1
(12). 若有以下的说明和语句，已知int类型占两个字节，则以下的输出结果为________。
main()
{ union un
{ int i;
double y;
};
struct st
{ char a[10];
union un b;
};
printf("%d\n",sizeof(struct st));
}
[分析、解答] 答案为18
本题的知识点是考察结构体、共用体变量占内存大小。具体参考知识难点解析1。
(13). 下面程序的输出是_______。
main()
{ enum em{em1=3,em2=1,em3};
char *aa[]={"AA","BB","CC","DD"};
printf("%s%s%s\n",aa[em1],aa[em2],aa[em3]);
}
[分析、解答] 答案为DDBBCC。题目所给枚举表中的枚举符em1和em2已通过赋值改变其值为3和1，而枚举符em3没有赋值，则其值为前面一个枚举符的值加1，即em3取值为2。这样在printf语句中输出的将是以aa[3]、aa[1]和aa[2]为起始地址的字符串”DD”、”BB”和”CC”，考虑到输出格式控制中各字符串之间没有换行符，所以程序运行后其输出结果是DDBBCC.
7．4 实验指导
1．实验目的
（1）掌握结构类型变量与数组的定义和使用；
（2）掌握使用结构指针和结构变量名使用结构成员的方法；
（3）掌握链表的基本概念和操作;
（4）掌握联合的概念与使用。
2．实验内容
编写程序并上机调试运行，做到充分理解程序的内涵。
(1)．输入并运行下面程序，观察结果，分析联合变量的存储特点。
(2)．有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括学生号，姓名，三门课成绩），计算出平均成绩。
(3)．下面的程序，构造一个如下图所示的三个结点的链表，并顺序输出链
表中结点的数据。
a b c
3．编程环境及程序代码
(1) 编程环境：Turbo C 2.0。
(2) 程序代码
第一题：
#include
void main( )
{
union
{ int i[2];
long k;
char c[4];
} t, *s=&t;
s->i[0]=0x39; /* 按照整型成员的类型赋值*/
s->i[1]=0x38;
printf("%lx\n ",s->k); /* 按照长整型成员的类型使用储存内容*/
printf("%c\n ",s->c[0]); /* 按照字符型成员的类型使用储存内容*/ }
第二题：
#include "stdio.h"
struct student
{ char num[6];
char name[8];
int score[3];
float avr;
} stu[5];
main()
{ int i,j,sum;
/*input*/
for(i=0;i<5;i++)
{ printf("\n please input No. %d score:\n",i);
printf("stuNo:");
scanf("%s",stu[i].num);
printf("name:");
scanf("%s",stu[i].name);
sum=0;
for(j=0;j<3;j++)
{ printf("score %d.",j+1);
scanf("%d",&stu[i].score[j]);
sum+=stu[i].score[j];
}
stu[i].avr=sum/3.0;
}
}
第三题：
#include
struct node
{ int data;
struct node *next; /* 指向本结点类型的指针是实现链
*/
};
void main( )
{ struct node a,b,c,*h,*p; /* 定义三个结点h 是头指a.data=10; b.data=20; c.data=30; /* 结点的数据赋值*/ h=&a; /* 头指针指向a 结
a.next=&b; /* a 结点的指针指向b 结点
b.next=&c; /* b 结点的指针指向c 结点
c.next=NULL; /* c 结点的指针值为空，表示最后一
p=h; /* 遍历每一个结点，打印数据*/
while (p)
{ printf("%d ",p->data);
p=p->next; /* 指针移到下一个结点*/
}
}
结构体与共用体小结
结构体与共用体小结 一,结构体得概念与定义 1,结构体得定义 struct 结构体名 { 数据类型成员名1; 数据类型成员名1; 、、、 }; 这里数据类型可以就是复合类型,例如又就是一个结构体类型,即嵌套; 2,结构体变量得定义 struct 结构体名变量名1,变量名2,,,变量名n; 或: struct 结构体名 { 数据类型成员名1; 数据类型成员名1; 、、、 }结构体变量1,结构体变量2;
或: struct { 数据类型成员名1; 数据类型成员名1; 、、、 }结构体变量1,结构体变量2; 三种方式,第三种方式得话,每次要定义这个类型得结构体变量都要重复得写这一段代码; 其实定义了结构体后,struct 结构体名就就是一种新得类型,上述语句就像声明变量一样; 3,结构体变量得引用 只能对结构体变量中得各个成员分别输出,不能对一个结构体变量作为一个整体输出; 嵌套得结构体类型得引用: 结构体变量名、结构体类型成员名、内嵌结构体得成员名; 4,结构体变量得初始化 struct 结构体名变量名= {初始化数据};
或者在定义得时候就初始化: struct 结构体名 { 数据类型成员名1; 数据类型成员名1; 、、、 }变量名= {初始化数据}; 二,结构体数组 1,结构体数组得定义举例struct stu { int stu_nu; char name[20]; float score; }; struct stu student[5]; 或者: struct stu { int stu_nu;
char name[20]; float score; }student[5]; 或者: struct { int stu_nu; char name[20]; float score; }student[5]; 跟定义结构体变量得三种形式就是一样得,只不过这里每次定义得结构体变量就是一个数组;每一个student[i]都就是struct stu类型得; 2,结构体数组得初始化与引用 略; 三,结构体与指针 1,指向结构体得指针得定义,同上,也就是三种形式; struct employees employee1,*p1; 或者: struct employees
结构体定义区
/******************** * 结构体定义区 * ********************/ typedef struct PID { int16_t pConst; // 比例常数 Proportional Const int16_t iConst; // 积分常数 Integral Const int16_t dConst; // 微分常数 Derivative Const int16_t position; int16_t hisPosition; int16_t lastPosition[10]; }PID; /*********************************************************** * 函数名称：PID参数初始化 * 功能描述：初始化PID参数，并实现P、I、D三个参数的整定 * 参数列表： * 返回结果：无 ***********************************************************/ void PIDInit(PID *iPID) { memset(iPID, 0, sizeof(iPID)); //将所有值清零 iPID->pConst = 2; // 比例常数 Proportional Const iPID->iConst = 0; // 积分常数 Integral Const iPID->dConst = 8; // 微分常数 Derivative Const } /*********************************************************** * 函数名称：PID控制程序 * 功能描述： * 参数列表： * 返回结果：无 ***********************************************************/ void PIDCalc( PID *cPID) { int16_t pGain; //P增益
C语言自定义数据类型
自定义数据类型 结构体 结构体是程序员在程序中自定义的一种数据类型，在说明和使用之前必须先定义它，也就是构造它。定义一个结构体的语法格式如下： Struct 结构体类型名 { 成员1的数据类型名成员1名称； 成员2的数据类型名成员2名称； . . 成员n的数据类型名成员n名称； }结构体变量表={成员初始化}； 注意成员可以由若干个不同的数据类型组成，每个成员也可以是结构体，即可以嵌套定义。 例如： Struct student { Long num; Char name; Char sex; Float score; }; 已经定义的某种结构体类型可以视为一种标准的数据类型，它的使用方法与标准数据类型使用方法相同，可以用来定义变量、数组、指针。 结构体变量说明 结构体变量的说明在程序的变量说明部分给出，一般在结构定义之后，它的语法格式如下： Struct 结构类型名结构变量名表； 例如： Struct student stu； 指出了结构变量stu是student类型的变量，它由四个成员组成，每个成员的数据类型和名字都与student结构定义中给出的相同。系统完全按照结构定义时制定的内存模式为结构变量分配内存空间。 可以在定义结构体类型的同时给出结构体变量。 Struct student { Long num; Cha name[20]; Cha sex; Float score; }stu1,stu2; 这种形式与前面给出的结构定义和结构说明分开处理效果相同。
结构体成员访问 结构体成员是通过结构体变量名和成员名进行访问的，不能把他作为一个整体进行访问。其访问格式如下： 结构体变量名.成员名 其中运算符.是成员访问运算符，其运算级别是最高的，和圆括号运算符()、下标运算符[]是同一级别的。如果结构体成员是指针变量，则访问格式为： *https://www.360docs.net/doc/4116826858.html, 如果某个结构体变量的成员数据类型又是一个结构体，则访问方式为： 外层结构体变量名.外层成员名.内层成员名 可以在定义结构体变量的同时对结构体变量初始化。 {结构体成员}结构体变量={初始数据}； struct student { long num; char name[20]; char sex; float score; } stu1={200401L,"ZhangHong",'f',92.5f}; 对于嵌套的结构体类型数据，访问格式为： 结构体变量名1.结构体变量名2.成员名 结构体变量初始化的格式如下： struct 结构体名 {结构体成员}结构体变量={初始数据}； 初始数据类型必须与结构成员的数据类型相匹配，并且先后顺序一一对应赋值。 要对结构体变量的成员地址进行访问，其语法格式为： &结构体变量.成员名 当一个指针变量用来指向一个结构变量时，称为结构体指针变量。结构体指针变量中的值是所指向的结构体变量的首地址。 结构体指针变量： Struct 结构名*结构体指针变量名 Struct student *pstu; 必须先赋值后使用，把结构体变量的首地址赋给指针变量，不能把结构名或结构体变量名赋给指针变量。 pstu=&stu1; 结构体名和结构体变量是两个不同的概念，结构体名只能表示一个结构形式，编译系统并不对它分配内存空间，只有当某变量被说明为这种类型的结构时，才对该变量分配存储空间。这是因为结构体变量被定义后相当于标准数据类型被使用。 利用结构体指针变量访问成员如下： （*结构体指针变量）.成员名 或者： 结构体指针变量->成员名 后一种形式较为方便，容易区分。
C语言结构体和共用体实验报告
实验九参考程序 实验 9－ 1 /**************************************************************** * 实验 9.1 * * ( 1 )为某商店的商品设计合适的结构体 (PRODUCT) 。每一种商品包含编号 (number) 、 * 名称 (name) 、价格 (price) 、折扣 (discount)4 项信息，根据表 9-1 ，为这些信 息选择合适的数据类型。 * (2)建立 2个函数，以实现对商品的操作。 input 函数实现商品的输入； * display 函数显示商品信息。要求这 2个函数都以商品的结构体 (PRODUCT) 指针为 参数。 * (3 )在主函数中为商品键盘定义一个结构体变量 (keyboard) ，利用 input 函数实现键 盘信息的输入； * 定义一个结构体数组 (elec_device[3]) ，利用 input 函数实现冰箱、 空调、电视 信息的输入； * 最后利用 display 函数显示 4 种商品的信息。 * * 表 9-1 #include
结构体和共用体习题
习题六 1. 从下列四个选项中选择一个正确的填入括号中。 （1）在说明一个结构体变量时系统分配给它的存储空间是（D）。 A该结构体中第一个成员所需存储空间 B该结构体中最后一个成员所需存储空间 C该结构体中占用最大存储空间的成员所需存储空间 D该结构体中所有成员所需存储空间的总和 （2）在说明一个共用体变量时系统分配给它的存储空间是（D ）。 A该共用体中第一个成员所需存储空间 B该共用体中最后一个成员所需存储空间 C该共用体中占用最大存储空间的成员所需存储空间 D该共用体中所有成员所需存储空间的总和 （3）共用体类型在任何给定时刻, （B）。 A所有成员一直驻留在内存中 B只有一个成员驻留在内存中 C部分成员驻留在内存中 D没有成员驻留在内存中 （4）以下定义结构体类型的变量st1，其中不正确的是（A ） A typedef stuct student { int num; int age; }STD; STD st1; B struct student { int num,age; }st1; C struct { int num; float age; }st1; D struct student { int num; int age; }; struct student st1; （5）已知职工记录描述为: struct workers {
int no; char name[20]; char sex; struct { int day; int month; int year; }birth; }; struct workers w; 设变量w中的”生日”应是”1993年10月25日”,下列对”生日”的正确赋值方式是（C）。 A day=25; month=10; year=1993; B w.day=25w.month=10; w.year=1993; C w.birth.day=25; w.birth.month=10; w.birth.year=1993; D birth.day=25; birth.month=10; birth.year=1993； （6）设有如下定义: struct sk { int a; float b; }data,*p; 若有p=&data;则对data中的a成员的正确引用是（B）。 A (*p).data.a B (*p).a C p->data.a D p.data.a 2.填空 （1）若有以下说明和定义且数组w和变量k已正确赋值，则对w数组中第k个元素中各成员的正确引用形式是w[k-1].b、w[k-1].c 、w[k-1].d 。 struct aa { int b; char c; double d; }; struct aa w[10]; int k=3; （2）若有以下说明和定义，则对x.b成员的另外两种引用形式是x->b-> 和p.b. 。 struct st { int a; struct st *b; }*p, x;
c语言结构体用法(转载)
C语言，结构体(struct) 用法 结构(struct) 结构是由基本数据类型构成的、并用一个标识符来命名的各种变量的组合。 结构中可以使用不同的数据类型。 1. 结构说明和结构变量定义 在T urbo C中, 结构也是一种数据类型, 可以使用结构变量, 因此, 象其它 类型的变量一样, 在使用结构变量时要先对其定义。 定义结构变量的一般格式为: struct 结构名 { 类型变量名; 类型变量名; ... } 结构变量; 结构名是结构的标识符不是变量名。 类型为第二节中所讲述的五种数据类型(整型、浮点型、字符型、指针型和 无值型)。 构成结构的每一个类型变量称为结构成员, 它象数组的元素一样, 但数组中 元素是以下标来访问的, 而结构是按变量名字来访问成员的。
下面举一个例子来说明怎样定义结构变量。 struct string { char name[8]; int age; char sex[2]; char depart[20]; float wage1, wage2, wage3, wage4, wage5; } person; 这个例子定义了一个结构名为string的结构变量person, 如果省略变量名 person, 则变成对结构的说明。用已说明的结构名也可定义结构变量。这样定义 时上例变成: struct string { char name[8]; int age; char sex[2]; char depart[20]; float wage1, wage2, wage3, wage4, wage5; }; struct string person; 如果需要定义多个具有相同形式的结构变量时用这种方法比较方便, 它先作 结构说明, 再用结构名来定义变量。 例如: struct string T ianyr, Liuqi, ...; 如果省略结构名, 则称之为无名结构, 这种情况常常出现在函数内部, 用这 种结构时前面的例子变成:
结构体的定义及初始化
?结构体类型定义 struct [结构体名] { 类型标识符成员名； 类型标识符成员名； ……………. }；成员类型可以是基本型或构造型 struct是关键字,不能省略合法标识符 可省:无名结构体 结构体的说明及结构体变量的定义
例struct student { int num; char name[20]; char sex; int age; float score; char addr[30]; }; name num sex age score addr 2字节 2字节 20字节 1字节 4字节 30字节 … ….. 结构体类型定义描述结构 的组织形式,不分配内存 例子图解
?结构体类型定义 struct [结构体名] { 类型标识符成员名； 类型标识符成员名； ……………. }；成员类型可以是基本型或构造型 struct是关键字,不能省略合法标识符 可省:无名结构体 结构体的说明及结构体变量的定义
(1) 在结构体说明的同时定义结构体变量,例如：struct example { char *name； int age; }guo,zhang；(2)直接定义结构体变量,例如： struct {char *name； int age; }guo,zhang 未给 出结 构体 名 (3) 把定义和说明分开,例如：struct example { char *name； int age; }； struct example guo,zhang；结构体变量占用内存的大小可用sizeof()运算来求出 ?结构体变量的定义
结构体的说明及结构体变量的定义?变量说明形式 struct 结构体名结构体变量名； ?注意： 结构变量的存储类型概念、它的寿命、可见 性及使用范围与普通变量、数组等完全一致。 结构体变量说明必须在结构类型定义之后， 二者也可同时进行。
C语言结构体共用体选择题新
1、变量 a 所占的内存字节数是。（假设整型int 为 4 字节） structstu {charname[20]; longintn; intscore[4]; }a; A)28B)30 C)32D)46 C 2、下列程序的输出结果是 A)5B)6 C)7D)8 structabc {inta,b,c;}; main() {structabcs[2]={{1,2,3},{4,5,6}};intt; t=s[0].a+s[1].b; printf("%d\n",t); } B 3、有如下定义 structperson{charname[9];intage;}; structpersoncalss[4]={"Johu",17, "Paul",19, "Mary",18, "Adam",16,}; 根据以上定义,能输出字母M 的语句是________ 。 A)printf("%c\n",class[3].name); B)printf("%c\n",class[3].name[1]); C)printf("%c\n",class[2].name[1]); D)printf("%c\n",class[2].name[0]); D 4、以下程序的输出是________ 。 structst {intx;int*y;}*p; intdt[4]={10,20,30,40}; structstaa[4]={50,&dt[0],60,&dt[0],60,&dt[0],60,dt[0],}; main() {p=aa; printf("%d\n",++(p->x)); } A)10B)11 C)51D)60 C 6、以下程序的输出结果是________ 。 structHAR {intx,y;structHAR*p;}h[2]; main() {inth[0].x=1;h[0].y=2; h[1].x=3;h[1].y=4;
结构体和共用体
第十一章结构体和共用体 11．1 本章基本知识结构 11．2 知识难点解析 1．结构体与共用体变量在计算机中占用多少内存？ [解答] 结构体变量所占的内存长度等于所有各成员的长度之和，每个成员分别占有自己的内存单元；共用体变量所占的内存长度等于最长的成员的长度。 2．结构体和共用体的有几种不同的引用方法？ [解答] 结构体和共用体一样，有两种引用办法，一种是采用成员（分量）运算符“.”；还有一种是采用指针的办法。下面以结构体为例说明这两种不同的引用的方法。 struct stu {int num; char name[10]; int age; } zhangsan, *lisi; 要访问学生zhangsan年龄的办法有两种：zhangsan.age 或者（&zhangsan） —>age； 要访问学生lisi年龄的办法也有两种：(*lisi).age 或者lisi—>age。
11．3 习题 1．选择题 (1)．以下程序运行的输出结果是( )。 main() {union {char i[2]; int m; }r; r.i[0]=2;r.i[1]=0; printf("%d\n",r.m); } A.2 B.1 C.0 D.不确定 [分析、解答] 答案为A。本题涉及共用体的概念。字符数组i[2]与整型变量m使用同一内存单元。M占用2个字节，高字节对应i[1],低字节对应i[0],所以答案为A。 (2)．有以下程序输出结果是( )。 #include
C语言结构体习题及答案
第9章结构体 1．定义以下结构体类型 struct s { int a; char b; float f; }; 则语句printf("%d",sizeof(struct s))的输出结果为【】。 A) 3 B) 7 C) 6 D) 4 2．当定义一个结构体变量时，系统为它分配的内存空间是【】 A）结构中一个成员所需的内存容量 B）结构中第一个成员所需的内存容量 C）结构体中占内存容量最大者所需的容量 D）结构中各成员所需内存容量之和 3．定义以下结构体类型 struct s { int x; float f; }a[3]; 语句printf("%d",sizeof(a))的输出结果为【】 A) 4 B) 12 C) 18 D) 6 4．定义以下结构体数组 struct c { int x; int y; }s[2]={1,3,2,7}; 语句printf("%d",s[0].x*s[1].x)的输出结果为【】 A) 14 B) 6 C) 2 D) 21 5．运行下列程序段，输出结果是【】 struct country { int num; char name[10]; }x[5]={1,"China",2,"USA",3,"France",4, "England",5, "Spanish"}; struct country *p; p=x+2; printf("%d,%c",p->num,(*p).name[2]); A) 3,a B) 4,g C) 2,U D) 5,S
6．下面程序的运行结果是【】。 struct KeyWord { char Key[20]; int ID; }kw[]={"void",1,"char",2,"int",3,"float",4,"double",5}; main() { printf("%c,%d\n",kw[3].Key[0], kw[3].ID); } A) i,3 B) n,3 C) f,4 D) l,4 7．定义以下结构体类型 struct student { char name[10]; int score[50]; float average; }stud1; 则stud1占用内存的字节数是【】。 A) 64 B) 114 C) 228 D) 7 8．如果有下面的定义和赋值，则使用【】不可以输出n中data的值。struct SNode { unsigned id; int data; }n,*p; p=&n; A) p.data B) n.data C) p->data D) (*p).data 9.根据下面的定义，能输出Mary的语句是【】。 struct person { char name[9]; int age; }; struct person class[5]={"John",17,"Paul",19,"Mary",18,"Adam",16}; A) printf("%s\n",class[1].name); B) printf("%s\n",class[2].name); C) printf("%s\n",class[3].name);
C程序实验报告十 结构体与共用体
实验10 结构体与公用体 1．实验目的、要求 （1）掌握结构体类型变量的定义和使用。 （2）掌握结构体类型数组的概念和使用。 （3）掌握公用体的概念与使用。 2．实验内容 （1）输入程序并运行，观察运行结果 #include “stdio.h” int 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 )； return(0); } 运行此程序：按F2保存源程序，按F9完成一次编译连接，无提示错误，按任意键返回源程序行，按ctrl+F9运行，按alt+F5看结果，结果显示：6 （2）输入程序并运行，观察运行结果 union ks { int a； int b； }； union ks s[4]； union ks *p； #include “stdio.h” int main( ) { int n=1, i； printf(“\n”)； for(i=0；i<4；i++) { s[i].a=n； s[i].b=s[i].a+1； n=n+2； } p=&s[0]； printf(“%d,”,p->a)； printf(“%d” ,++ p->a)； return(0); } 运行此程序：按F2保存源程序，按F9完成一次编译连接，无提示错误，按ctrl+F9运行，按任意键返回源程序行，按alt+F5看结果，结果显示：23 （3）编写程序 有10个学生，每个学生的数据包括学号、姓名、3门课的成绩，从键盘输入10个学生数据，要求打印出3门课总平均成绩，以及最高分的学生的数据（包括学号、姓名、3门课成绩、平均分数）。要求用input 函数输入10个学生数据；用average函数求总平均分；用
c语言结构体与共用体之间的区别
https://www.360docs.net/doc/4116826858.html,/2005/03/25/12365.html 所谓共用体类型是指将不同的数据项组织成一个整体，它们在内存中占用同一段存储单元。其定义形式为： union 共用体名 {成员表列}； 7.5.1 共用体的定义 union data { int a ; float b ; d o u b l e c ; c h a r d ; } obj; 该形式定义了一个共用体数据类型union data ，定义了共用体数据类型变量o b j。共用体 数据类型与结构体在形式上非常相似，但其表示的含义及存储是完全不同的。先让我们看一个小例子。 [例7 - 8 ] union data /*共用体* / { int a; float b; double c; char d; } m m ; struct stud /*结构体* / { int a; float b; double c; char d; } ; m a i n ( ) { struct stud student printf("%d,%d",sizeof(struct stud),sizeof(union data)); } 程序的输出说明结构体类型所占的内存空间为其各成员所占存储空间之和。而形同结构体的
共用体类型实际占用存储空间为其最长的成员所占的存储空间。详细说明如图7 - 6所示。 对共用体的成员的引用与结构体成员的引用相同。但由于共用体各成员共用同一段内存 空间，使用时，根据需要使用其中的某一个成员。从图中特别说明了共用体的特点，方便程序设计人员在同一内存区对不同数据类型的交替使用，增加灵活性，节省内存。 7.5.2 共用体变量的引用 可以引用共用体变量的成员，其用法与结构体完全相同。若定义共用体类型为： union data /*共用体* / { int a; float b; double c; char d; } m m ; 其成员引用为：m m . a , m m . b , m m . c , m m . d 但是要注意的是，不能同时引用四个成员，在某一时刻，只能使用其中之一的成员。 [例7-9] 对共用体变量的使用。 m a i n ( ) { union data { int a; float b; double c; char d; } m m ; m m . a = 6 ; printf("%d\n",mm.a); m m . c = 6 7 . 2 ; p r i n t f ( " % 5 . 1 l f \ n " , m m . c ) ; m m . d = ' W ' ; m m . b = 3 4 . 2 ; p r i n t f ( " % 5 . 1 f , % c \ n " , m m . b , m m . d ) ; }
结构体与共用体
试卷编号：825 所属语言：C语言 试卷方案：结构体与共用体 试卷总分：90分 共有题型：5种 一、填空共5题（共计10分） 第1题（2.0分）题号:205 结构体是不同数据类型的数据集合,作为数据类型, 必须先说明结构体【1】,再说明结构体变量. 答案： =======(答案1)======= 类型 第2题（2.0分）题号:208 将函数funl 的入口地址赋给指针变量p的语句是【1】. 答案： =======(答案1)======= p=funl; 第3题（2.0分）题号:232 设有以下结构类型说明和变量定义,则变量a在内存所占字节数是【1】 . struct stud { char num[6]; int s[4]; double ave; } a,*p; 答案： =======(答案1)=======
第4题（2.0分）题号:345 若在程序中用到"strlen()"函数时,应在程序开头写上包含命令# include "【1】". 答案： =======(答案1)======= string.h 第5题（2.0分）题号:803 预处理命令行都必须以【1】号开始. 答案： =======(答案1)======= # 二、单项选择共20题（共计40分） 第1题（2.0分）题号:464 以下描述中，正确的是（）。 A:预处理是指完成宏替换和文件包含中指定的文件的调用 B:预处理指令只能位于C源文件的开始 C:C源程序中凡是行首以#标识的控制行都是预处理指令 D:预处理就是完成C编译程序对C源程序第一遍扫描,为编译词法和语法分析作准备答案：C 第2题（2.0分）题号:472 下列程序运行结果为： #define P 3 #define S(a) P*a*a main() {int ar; ar=S(3+5); printf("\n%d",ar); } A:192 B:29
(1)定义结构体的关键字是
(1) 定义结构体的关键字是，定义共用体的关键字是。 (2) 结构体和共用体的相同点是，不同点是。 (3) 若有以下定义和语句，则sizeof(a)的值是__ ___，而sizeof(b)的值是__ _。struct tu { int m; char n; int y;}a; struct { float p, char q; struct tu r} b; (4) 设有下面结构类型说明和变量定义，则变量a在内存所占字节数是。如果将该结构改成共用体，结果为。 struct stud { char num[6]; int s[4]; double ave; } a; (5) 下面程序用来输出结构体变量ex所占存储单元的字节数，请填空。 struct st { char name[20]; double score; }; main() { struct st ex ; printf("ex size: %d\n",sizeof( )); } (6) 下面定义的结构体类型拟包含两个成员,其中成员变量info用来存入整形数据;成员变量link是指向自身结构体的指针,请将定义补充完整。 struct node { int info; link; } (7) 以下程序执行后输出结果是。 main() { union { unsigned int n; unsigned char c; } u1; u1.c='A'; printf("%c\n",u1.n); } (8) 变量root如图所示的存储结构，其中sp是指向字符串的指针域，next是指向该结构的指针域，data用以存放整型数。请填空，完成此结构的类型说明和变量root的定义。 root struct { char *sp ; __ __; _ _; } root; 2. 阅读下面的程序，写出程序结果 (1) struct info { char a,b,c;}; main() { struct info s[2]={{‘a’,‘b’,‘c’},{‘d’,‘e’,‘f’}};int t; t=(s[0].b-s[1].a)+(s[1].c-s[0].b); printf("%d\n",t); } (2)
c语言结构体共用体选择题新
c语言结构体共用体选择 题新 The pony was revised in January 2021
1、变量a所占的内存字节数是________。（假设整型i n t为4字节） struct stu { char name[20]; long int n; int score[4]; } a ; A) 28 B) 30 C) 32 D) 46 C 2、下列程序的输出结果是 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); } B 3、有如下定义 struct person{ char name[9]; int age;}; struct person calss[4]={ "Johu",17, "Paul",19, "Mary",18, "Adam",16,}; 根据以上定义,能输出字母M的语句是________。 A) printf("%c\n",class[3].name); B) printf("%c\n",class[3].name[1]); C) printf("%c\n",class[2].name[1]); D) printf("%c\n",class[2].name[0]);
D 4、以下程序的输出是________。 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)); } A) 10 B) 11 C) 51 D) 60 C 6、以下程序的输出结果是________。 struct HAR
c语言结构体定义结构体
c语言结构体定义结构体 代码1 定义结构体_m_usmart_devstruct _m_usmart_dev{struct _m_usmart_nametab *funs;//函数名指针 void (*init)(u8);//初始化u8 (*cmd_rec)(u8*str);//识别函数名及参数void (*exe) (void); //执行void (*scan)(void); //扫描u8 fnum; //函数数量u8 pnum; //参数数 量u8 id;//函数idu8 sptype;//参数显示类型(非字符串参数):0,10 进制;1,16 进制; u16 parmtype;//参数的类型u8 plentbl[MAX_PARM]; //每个参数的长度暂存表u8 parm[PARM_LEN]; //函数的参数}; 代码2 定义_m_usmart_dev 类型的结构体并对其赋初始值 struct _m_usmart_dev usmart_dev={usmart_nametab,usmart_init,usmart_cmd_rec,usmart_exe,usmart_scan, sizeof(usmart_nametab)/sizeof(struct _m_usmart_nametab),//函数数量0, //参数数 量0, //函数ID1,//参数显示类型,0,10 进制;1,16 进制0,//参数类型.bitx:,0,数字;1, 字符串0, //每个参数的长度暂存表,需要MAX_PARM 个0 初始化0,//函数的参 数,需要PARM_LEN 个0 初始化}; 上边代码可理解为 struct _m_usmart_dev{struct _m_usmart_nametab *funs;//函数名指针 void (*init)(u8);//初始化u8 (*cmd_rec)(u8*str);//识别函数名及参数void (*exe) (void); //执行void (*scan)(void); //扫描u8 fnum; //函数数量u8 pnum; //参数数 量u8 id;//函数idu8 sptype;//参数显示类型(非字符串参数):0,10 进制;1,16 进制; u16 parmtype;//参数的类型u8 plentbl[MAX_PARM]; //每个参数的长度暂存表u8 parm[PARM_LEN]; //函数的参数} usmart_dev={usmart_nametab,usmart_init,usmart_cmd_rec,usmart_exe,usmart_scan,
结构体与联合体习题含答案
2013年结构体与联合体习题 选择题 1、若程序中有以下的说明和定义： struct abc { int x;char y; } 花括号后少了分号。 struct abc s1,s2; 则会发生的情况是______。 A) 编译时错B) 程序将顺序编译、连接、执行 C) 能顺序通过编译、连接、但不能执行D) 能顺序通过编译、但连 接出错 2、有以下程序段 struct st { int x; int *y;}*pt; int a[]={1,2};b[]={3,4}; struct st c[2]={10,a,20,b}; pt=c; 以下选项中表达式的值为11的是 A) *pt->y B) pt->x C) ++pt->x D) (pt++)->x 3、有以下说明和定义语句 struct student { int age; char num[8];}; struct student stu[3]={{20,"200401"},{21,"200402"},{19,"200403"}}; struct student *p=stu; 以下选项中引用结构体变量成员的表达式错误的是______。 A) (p++)->num B) p->num C) (*p).num D) stu[3].age 4、设有如下枚举类型定义 enum language {Basic=3,Assembly=6,Ada=100,COBOL,Fortran}; 枚举量Fortran的值为______。 A) 4 B) 7 C) 102 D) 103 5、以下叙述中错误的是_________。 A)可以通过typedef增加新的类型 B)可以用typedef将已存在的类型用一个新的名字来代表 C)用typedef定义新的类型名后，原有类型名仍有效 D)用typedef可以为各种类型起别名，但不能为变量起别名 6、有以下程序段 typedef struct NODE
C语言程序设计 结构体与共用体
页眉内容 一、选择题 1、定义结构类型时，下列叙述正确的是（） A、系统会按成员大小分配每个空间 B、系统会按最大成员大小分配空间 C、系统不会分配空间 D、以上说法均不正确 2、已知结构类型变量x的初始化值为{“20”,30,40,35.5},请问合适的结构定义是（） A、Struct s{int no;int x,y,z}; B、Struct s{char no[2];int x,y,z}; C、Struct s{int no;float x,y,z}; D、Struct s{char no[2];float x,y,z}; 3、若程序中有定义struct abc{int x;char y;};abc s1,s2;则会发生的情况是（） A、编译时会有错误 B、链接时会有错误 C、运行时会有错误 D、程序没有错误 4、已知学生记录描述为 struct student {int no; char name[20]; char set; struct {int year; int month; int day; }birth;}; struct student s; 设变量s中的“生日”应是“1984年11月11日”，下列对生日的正确赋值方式是（ ). A)year=1984; B)birth.year=1984; month=11; birth.month=11; day=11; birth.day=11; C)s.year=1984; D)s.birth.year=1984; s.month=11; s.birth.month=11; s.day=11; s.birth.day=11; 5、当说明一个结构体变量时系统分配给它的内存是（ ). A)各成员所需内存量的总和 B)结构中第一个成员所需内存量 C)成员中占内存量最大者所需的容量 D)结构中最后一个成员所需内存量 6、以下对结构体类型变量的定义中不正确的是（ ). A)#define STUDENT struct student B)struct student STUDENT {int num; {int num; float age; float age; }std1; }std1; C)struct D)struct {int num; int num;
C结构体应用全攻略
C结构体应用全攻略——入门、进阶、提高、扩展 在学习结构体之前，你会很自然的想到使用如下的变量来描述： name, height, weight, strong, modfile。 好了，现在来给Kula和K分别进行描述，你就需要在变量名上加以区分。对于Kula你有了 Kula_name, Kula_height, Kula_weight, Kula_strong, Kula_modfile 对于K，你有了 K_name, K_height, K_weight, K_strong, K_modfile 好，设想你现在要制作KOF2003了，我们需要一个函数根据这些信息在战斗中评价两位选手，这个函数看上去像是这样 int value(char *name, int height, int weight, int strong, char *modfile); 当然在实际测试中一个人物的信息可能不止这几个，也许他有30个之多，我相信你是不会写一个有30个参数的函数的（除非你为Microsoft工作）。更糟糕的是，如果由于版本更新发现30个参数里有15个是多余的，在修改了函数定义之后，你还要修改无数的不只位置函数调用。汗！ 现在，结构体来救你了(e文：the struct comes to rescue)。看看如何用结构体定义一个拳皇人物吧。首先我们定义一个结构体类型： struct FIGHTER { char *name; /*元素1*/ int height; /*元素2*/ int weight; /*元素3*/ int strong; /*元素4*/ char *modfile; /*元素5*/