第九章使用结构体类型处理组合数据 c语言

第九章使用结构体类型处理组合数据

1.定义和使用结构体变量

2.结构体数组

3.结构体指针

4.用结构体变量和结构体变量的指针作函数参数

5.用指针处理链表

6.共用体、枚举类型

正文

1.定义和使用结构体变量

若只保存某个学生的学号：可以使用int 变量。

若保存所有学生的学号：可以使用int 型的数组。

同理，若保存所有学生的姓名：可以使用char型的数组。

若保存所有学生某科成绩：可以使用float 型的数组。

但是，如果要同时保存某一个学生的学号，姓名，性别、入学时间及各科成绩，该用什么保存？

自己建立结构体类型

将一个学生的学号、姓名、性别、年龄和地址分别用以下变量来表示：

int num; char name[20]; char sex;

int age; char addr[30];

Num name sex age score addr

100101 Li Fun M 18 87.5 Beijing

声明一个结构体类型的一般形式为：

struct 结构体名

｛成员表列=类型名+成员名｝；

如：struct student {

int num;char name[20];char sex;

int age;float score;char addr[30];

}

可以采取以下3种方法定义结构体类型变量：

(1)先声明结构体类型再定义变量名

例如：struct student student1, student2;

| | |

结构体类型名结构体变量名

定义了student1和student2为struct student类型的变量，即它们具有struct student 类型的结构.

student1 100102 WangLi F 20 98 Beijing

student2 100101 ZhangXin M 19 90.5 Shanghai

在定义了结构体变量后，系统会为之分配内存单元。

例如:student1和student2在内存中各占63个字节（4+20+1+4+4+30=63）。（我们的VC）

注意：

将一个变量定义为标准类型（基本数据类型）与定义为结构体类型不同之处在于后者不仅要求指定变量为结构体类型，而且要求指定为某一特定的结构体类型，因为可以定义出许许多多种具体的结构体类型。

(2)在声明类型的同时定义变量

这种形式的定义的一般形式为:

struct结构体名

｛

成员表列

｝变量名表列；

struct student

｛int num；

char name[20]；

char sex；

int age；

float score；

char addr[30]；

｝student1,student2;//它的作用与第一种方法相同，即定义了两个struct

//student 类型的变量student1 student2

(3) 直接定义结构体类型变量

//注意：

(2)对结构体中的成员（即“域”），可以单独使用，它的作用与地位相当于普通变量。

(3)成员也可以是一个结构体变量。

(4)成员名可以与程序中的变量名相同,二者不代表同一对象。

其一般形式为:

struct

｛

成员表列

｝变量名表列；

即不出现结构体名。

例如：struct date

{ int month;

int day;

int year;

};

struct student

{ int num；

char name[20]；

char sex；

int age；

float score；

struct date birthday；

char addr[30]；

} student1,student2;

Num name sex age birthday addr

Month day year

引用结构体变量中成员的方式为

结构体变量名.成员名

例如：student1.num表示student1变量中的num成员,即student1的num(学号)项。可以对变量的成员赋值,例如:student1.num=10010;“.”是成员(分量)运算符,它在所有的运算符中优先级最高,因此可以把student1.num作为一个整体来看待。上面赋值语句的作用是将整数10010赋给student1变量中的成员num。

(2) 如果成员本身又属一个结构体类型,则要用若干个成员运算符,一级一级地找到最低的一级的成员。只能对最低级的成员进行赋值或存取以及运算。

例如:对上面定义的结构体变量student1, 可以这样访问各成员:

student1.num

student1.birthday.month 注意：

不能用student1.birthday来访问student1变量中的成员birthday,因为birthday本身是一个结构体变量。

(3) 对结构体变量的成员可以像普通变量一样进行各种运算（根据其类型决定可以进行的运算）。

例如：

student2.score=student1.score;

sum=student1.score+student2.score;

student1.age++;

++student2.age;由于“．”运算符的优先级最高，因此ｓｔｕｄｅｎｔ１．ａｇｅ＋＋是对ｓｔｕｄｅｎｔ１．ａｇｅ进行自加运算，而不是先对ａｇｅ进行自加运算。

4) 可以引用结构体变量成员的地址，也可以引用结构体变量的地址。

例如：

scanf(″%d″，&student1.num);

（输入student1.num的值）

printf(″%o″，＆student1）；

（输出student1的首地址）

但不能用以下语句整体读入结构体变量，

例如：

scanf（″%d，％s，％c，％d，％f，％s″，＆student1）；

结构体变量的地址主要用作函数参数，传递结构体变量的地址。

例对结构体变量初始化.

#include

void main（）//运行结果：

{struct student //No.：10101

｛long int num；//name：LiLin sex：Ｍ

char name[20]; //address：123 Beijing Road

char sex；

char addr[20]；

｝a={10101，″LiLin″，′M′，″123 Beijing Road″｝；/* 对结构体变量a赋初值*/

printf(″No.:%ld＼nname:%s＼nsex:%c＼naddress:%s＼n″，a.num，https://www.sodocs.net/doc/2a10165120.html,，a.sex，a.addr);｝

一个结构体变量中可以存放一组数据（如一个学生的学号、姓名、成绩等数据）。

如果有１０个学生的数据需要参加运算，显然应该用数组，这就是结构体数组。

结构体数组与以前介绍过的数值型数组不同之处在于每个数组元素都是一个结构体类型的数据，它们都分别包括各个成员（分量）项。

定义结构体数组

和定义结构体变量的方法相仿，只需说明其为数组即可。

例如：

struct student

{int num;char name[20];char sex;int age;//以上定义了一个数组stu，数组有３个素，均为struct student类型数据。

float score;char addr[30];

}；

struct student stu[3];

也可以直接定义一个结构体数组，例如：

strcut student

{int num;

…} stu[3];

结构体数组的初始化

与其他类型的数组一样，对结构体数组可以初始化。例如：

struct student

｛int num;char name[20]；char sex；

int age；float score; char addr[30]；

｝stu［2］＝{{10101，″LiLin″，′M′，18，87.5，″103 BeijingRoad″｝，｛10102，″Zhang Fun″，′M′，19，99，″130 Shanghai Road″}}；

图11-4

当然，数组的初始化也可以用以下形式：//结构体数组初始化的一般形式是在定义数组

的后面加上“＝｛初值表列｝；”。

struct student

｛int num；

…

｝；

struct student str[]={{…},{…},{…}}；

即先声明结构体类型，然后定义数组为该结构体类型，在定义数组时初始化。

结构体数组应用举例

例对候选人得票的统计程序。设有3个候选人，每次输入一个得票的候选人的名字，

要求最后输出各人得票结果。

#include

#include

struct person

{

char name[20];in count;

};

leader[3]={“Li”,0, “ Zhang”,0, “ Fun”,0}

例

void main()

{ int i,j; char leader_name[20];

for(i=1;i<=10;i++)

{

scanf(“%s”,leader_name);

for(j=0;j<3;j++)

if(strcmp(leader_name,leader[j].name)==0)

leader[j].count++;

}

printf(“\n”);

for(i=0;i<3;i++) printf(“%5s:%d\n”,leader[i].name,leader[i].count);} 运行结果：

Ｌｉ↙

Ｌｉ↙

Ｆｕｎ↙

Ｚｈａｎｇ↙

Ｚｈａｎｇ↙

Ｆｕｎ↙

Ｌｉ↙

Ｆｕｎ↙

Ｚｈａｎｇ↙

Ｌｉ↙

Ｌｉ:４

Ｚｈａｎｇ:３

Ｆｕｎ:３

一个结构体变量的指针就是该变量所占据的内存段的起始地址。可以设一个指针变量，用来指向一个结构体变量，此时该指针变量的值是结构体变量的起始地址。指针变量也可以用来指向结构体数组中的元素。

指向结构体变量的指针

下面通过简单例子来说明指向结构体变量的指针变量的应用。

例指向结构体变量的指针的应用

#include

#include

void main()

{struct student{long num;char name[20];

char sex; float score;};

struct student stu_1;

struct student* p; p=&stu_1;

stu_1.num=89101;strcpy(stu_https://www.sodocs.net/doc/2a10165120.html,,”LiLin”);

stu_1.sex=…M?;stu_1.score=89.5;

printf(″No.:%ld＼nname:%s＼nsex:%c＼nscore:%f＼n″，stu_1.num，stu_https://www.sodocs.net/doc/2a10165120.html,，stu_1.sex，stu_1.score);

printf(″No.:%ld＼nname:%s＼

(*p).sex，(*p).score);

}

运行结果：

Ｎｏ．：89101

name：LiLin

sex：Ｍ

score：89.500000

Ｎｏ．：89101

name：LiLin

sex：Ｍ

score：89.500000

程序分析：

在函数的执行部分将结构体变量ｓｔｕ-１的起始地址赋给指针变量ｐ，也就是使ｐ指向ｓｔｕ-１,然后对ｓｔｕ-１的各成员赋值。第一个ｐｒｉｎｔｆ函数是输出ｓｔｕ-１的各个成员的值。用ｓｔｕ-１．ｎｕｍ表示ｓｔｕ-１中的成员ｎｕｍ，依此类推。第二个ｐｒｉｎｔｆ函数也是用来输出ｓｔｕ-１各成员的值，但使用的是（*ｐ）．ｎｕｍ这样的形式。

以下3种形式等价：

①结构体变量．成员名

②（*ｐ）．成员名

③ｐ->成员名

其中->称为指向运算符。

请分析以下几种运算：

ｐ->ｎ得到ｐ指向的结构体变量中的成员ｎ的值。

ｐ->ｎ＋＋得到ｐ指向的结构体变量中的成员ｎ的值，用完该值后使它加１。

＋＋ｐ->ｎ得到ｐ指向的结构体变量中的成员ｎ的值加１，然后再使用它。

例指向结构体数组的指针的应用

#include

struct student

{int num;char name[20];char sex;int age;};

struct student stu[3]=｛｛10101，″Li Lin″，′M′，18｝，｛10102，″Zhang Fun″，′M′，19｝，｛10104，″WangMing″，′F′，20｝｝;

void main()

{ struct student *p;

printf(″No. Name sex age＼ｎ″）；

for（ｐ＝stu；ｐ＜stu＋３；p＋＋）

printf(″%5d %-20s %2c %4d＼n″，p->num，p->name，p->sex，p->age);

}

运行结果：

Ｎｏ．Ｎａｍｅｓｅｘａｇｅ

１０１０１LiLin Ｍ18

１０１０２Zhang Fun Ｍ19

１０１０４WangMing Ｆ20

程序分析：

ｐ是指向struct student结构体类型数据的指针变量。

在for语句中先使ｐ的初值为stu，也就是数组stu第一个元素的起始地址。

在第一次循环中输出stu[0]的各个成员值。

然后执行ｐ＋＋，使ｐ自加１。ｐ加１意味着p所增加的值为结构体数组stu的一个元素所占的字节数。执行ｐ++后p的值等于stu ＋1，ｐ指向stu[1]。

在第二次循环中输出stu[1]的各成员值。在执行ｐ＋＋后,p的值等于stu+2，再输出stu [2]的各成员值。在执行ｐ++后，ｐ的值变为stu +３，已不再小于stu+3了，不再执行循环。

注意：

(1) 如果ｐ的初值为stu，即指向第一个元素，则ｐ加１后p就指向下一个元素。例如:

(++p)->num先使ｐ自加１，然后得到它指向的元素中的num成员值（即10102）。

(p++)->num先得到ｐ->num的值（即10101），然后使ｐ自加１，指向stu[1]。

请注意以上二者的不同。

注意：

(2) 程序已定义了ｐ是一个指向struct student类型数据的指针变量，它用来指向一个struct student类型的数据,不应用来指向stu数组元素中的某一成员。

例如: ｐ＝ｓｔｕ［1］．ｎa ｍｅ; 如果要将某一成员的地址赋给p ，可以用强制类型转换，先将成员的地址转换成p 的类型。

例如：ｐ＝（ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *）ｓｔｕ［0］．ｎa ｍｅ； 将一个结构体变量的值传递给另一个函数，有3个方法:

(1) 用结构体变量的成员作参数。 (2) 用结构体变量作实参。 (3) 用指向结构体变量（或数组）的指针作实参，将结构体变量（或数组）的地址传给形参。 一、 结构体变量作函数参数

例 有一个结构体变量stu ，内含学生学号、姓名和3门课程的成绩。要求在main 函数中赋予值，在另一函数print 中将它们输出。今用结构体变量作函数参数。

#include struct student {

int num;

char name[20];

float score[3];

};

void main()

{

void print(struct student); struct student stu; stu.num=12345; strcpy(https://www.sodocs.net/doc/2a10165120.html,,"LiLin"); stu.score[0]=67.5; stu.score[1]=89; stu.score[2]=78.6;

print(stu);}

void print(struct student stu) { printf("%d,%s,%f,%f,%f",stu.num,https://www.sodocs.net/doc/2a10165120.html,,stu.score[0], stu.score[1],stu.score[2]);printf("\n");}

例 将上题改用指向结构体变量的指针作实参。 #include struct student {

int num;

char name[20]; float score[3];

};stu={12345, ″LiLi ″,67.5,89,78.6}; void main()

{void print(struct student *);

/*形参类型修改成指向结构体的指针变量*/ print(&stu);} /*实参改为stu 的起始地址*/

void print(struct student *p) /*形参类型修改了*/

{ printf("%d,%s,%f,%f,%f",p->num，p->name，

p->score［0］，p->score［1］，p->score［2］）；

/*用指针变量调用各成员的值*/

printf（″＼ｎ″）；}

运行结果：

１２３４５

ＬｉＬｉ

67.500000

89.000000

78.599998

程序分析：

此程序改用在定义结构体变量stu时赋初值，这样程序可简化些。

print函数中的形参ｐ被定义为指向struct student类型数据的指针变量。

注意在调用print函数时，用结构体变量str的起始地址＆stu作实参。在调用函数时将该地址传送给形参p(p是指针变量）。这样ｐ就指向stu。在print函数中输出ｐ所指向的结构体变量的各个成员值，它们也就是stu的成员值。

main函数中的对各成员赋值也可以改用scanf函数输入。

用指针处理链表

链表概述

链表是一种常见的重要的数据结构,是动态地进行存储分配的一种结构。

链表的组成：

头指针：存放一个地址，该地址指向一个元素

结点：用户需要的实际数据和链接节点的指针

用结构体建立链表：

struct student

｛int num；

float score；

struct student *next ；};

其中成员num和score用来存放结点中的有用数据（用户需要用到的数据），next是指针类型的成员，它指向struct student类型数据（这就是next所在的结构体类型）

#include

#define NULL 0

struct student

{long num; float score; struct student *next; };

main()

{ struct student a,b,c,*head,*p;

a. num=99101; a.score=89.5;

b. num=99103; b.score=90;

c. num=99107; c.score=85;

head=&a; a.next=&b; b.next=&c;

c.next=NULL; p=head;

do {printf("%ld %5.1f\n",p->num,p->score);

p=p->next; } while(p!=NULL);

}

运行结果：

1010189.5

1010390.0

1010785.0

程序分析：

开始时使head指向a结点，a.next指向b结点，b.next指向c结点，这就构成链表关系。

“c.next=NULL”的作用是使c.next不指向任何有用的存储单元。

在输出链表时要借助p，先使p指向a结点，然后输出a结点中的数据，“p=p->next”是为输出下一个结点作准备。p->next的值是b结点的地址，因此执行“p=p->next”后p就指向b结点，所以在下一次循环时输出的是b结点中的数据。

处理动态链表所需的函数

库函数提供动态地开辟和释放存储单元的有关函数：

(1)malloc函数

?其函数原型为void *malloc(unsigned int size);

?其作用是在内存的动态存储区中分配一个长度为size的连续空间。

?此函数的值（即“返回值”）是一个指向分配域起始地址的指针（类型为

?void）。

?如果此函数未能成功地执行（例如内存空间不足），则返回空指针(NULL)。

(2) calloc函数

?其函数原型为void *calloc（unsigned ｎ，unsigned size）;

?其作用是在内存的动态存储区中分配ｎ个长度为size的连续空间。

?函数返回一个指向分配域起始地址的指针；如果分配不成功，返回NULL。

?用calloc函数可以为一维数组开辟动态存储空间，n为数组元素个数，每个元素长度为Size。

(3) free函数

?其函数原型为void free（void *p）;

?其作用是释放由ｐ指向的内存区，使这部分内存区能被其他变量使用。

?ｐ是最近一次调用calloc或malloc函数时返回的值。free函数无返回值。

?以前的Ｃ版本提供的malloc和calloc函数得到的是指向字符型数据的指针。

ANSI Ｃ提供的malloc和calloc函数规定为void类型。

建立动态链表

所谓建立动态链表是指在程序执行过程中从无到有地建立起一个链表，即一个一个

地开辟结点和输入各结点数据，并建立起前后相链的关系

例写一函数建

立一个有3名学

生数据的单向

动态链表。

算法如图

我们约定学号不会为零，如果输入的学号为０，则表示建立链表的过程

如果输入的p1->num不等于０，则输入的是第一个结点数据（n=1），

算法的实现：

我们约定学号不会为零，如果输入的学号为０，则表示建立链表的过程完成，该结点不应

连接到链表中。如果输入的p1->num不等于０，则输入的是第一个结点数据（n=1），令head

＝p1，即把p1的值赋给head，也就是使head也指向新开辟的结点p1所指向的新开辟的

结点就成为链表中第一个结点

算法的实现

再开辟另一个结点并使p1指向它，接着输入该结点的数据.

如果输入的p1->num≠０，则应链入第２个结点（n=2), 将新结点的地址赋给第一

个结点的next成员.

接着使ｐ２＝ｐ１，也就是使ｐ２指向刚才建立的结点

算法的实现：

再开辟一个结点并使p1指向它，并输入该结点的数据。

算法的实现：

再开辟一个新结点，并使p1指向它，输入该结点的数据。由于p1->num的值为０，不再执行循环，此新结点不应被连接到链表中.

将NULL赋给p2->next.

建立链表过程至此结束，p1最后所指的结点未链入链表中，第三个结点的next成员的值为NULL，它不指向任何结点

建立链表的函数如下:

#include

#include

#define NULL 0 //令NULL代表０，用它表示“空地址

#define LEN sizeof(struct student) //令LEN代表struct //student类型数据的长度

struct student

{ long num;

float score; struct student *next;

};int n; //n为全局变量，本文件模块中各函数均可使用它

struct student *creat()

{struct student *head; struct student *p1,*p2; n=0;

p1=p2=( struct student*) malloc(LEN);

scanf("%ld,%f",&p1->num,&p1->score);

head=NULL;

while(p1->num!=0)

{ n=n+1; if(n==1)head=p1; else p2->next=p1;

p2=p1; p1=(struct student*)malloc(LEN);

scanf("%ld,%f",&p1->num,&p1->score);

}

p2->next=NULL; return(head);}

输出链表

首先要知道链表第一个结点的地址，也就是要知道head的值。

然后设一个指针变量p,先指向第一个结点，输出ｐ所指的结点

然后使ｐ后移一个结点，再输出.

直到链表的尾结点。

例编写一个输出链表的函数print.

void print(struct student *head)

{struct student *p;

printf("\nNow,These %d records are:\n",n); p=head;

if(head!=NULL)

do

{printf("%ld %5.1f\n",p->num,p->score);

p=p->next;

}while(p!=NULL);

}

对链表的删除操作

从一个动态链表中删去一个结点，并不是真正从内存中把它抹掉，而是把它从链表中分离开来，只要撤销原来的链接关系即可。

例写一函数以删除动态链表中指定的结点.

解题思路:

从p指向的第一个结点开始，检查该结点中的num值是否等于输入的要求删除的那个学号。如果相等就将该结点删除，如不相等，就将p后移一个结点，再如此进行下去，直到遇到表尾为止。

可以设两个指针变量p1和p2，先使p1指向第一个结点。

如果要删除的不是第一个结点，则使p1后移指向下一个结点(将p1->next赋给p1)，在此之前应将p1的值赋给p2 ，使p2指向刚才检查过的那个结点。

注意：

①要删的是第一个结点（ｐ１的值等于ｈｅａｄ的值，如图１1-２0（ａ）那样），则应将ｐ１->ｎｅｘｔ赋给ｈｅａｄ。这时ｈｅａｄ指向原来的第二个结点。第一个结点虽然仍存在，但它已与链表脱离，因为链表中没有一个结点或头指针指向它。虽然ｐ１还指向它，它仍指向第二个结点，但仍无济于事，现在链表的第一个结点是原来的第二个结点，原来第一个结点已“丢失”，即不再是链表中的一部分了。

注意：

①要删的是第一个结点（ｐ１的值等于ｈｅａｄ的值，如图１1-２0（ａ）那样），则应将ｐ１->ｎｅｘｔ赋给ｈｅａｄ。这时ｈｅａｄ指向原来的第二个结点。第一个结点虽然仍存在，但它已与链表脱离，因为链表中没有一个结点或头指针指向它。虽然ｐ１还指向它，它仍指向第二个结点，但仍无济于事，现在链表的第一个结点是原来的第二个结点，原来第一个结点已“丢失”，即不再是链表中的一部分了。

aasdasdasdasdasd

删除结点的函数del:

struct student *del(struct student *head,long num)

{struct student *p1,*p2;

if (head==NULL){printf("\nlist null!\n");goto end;}

p1=head;

while(num!=p1->num && p1->next!=NULL) {p2=p1;p1=p1->next;}

if(num==p1->num)

{if(p1==head) head=p1->next;

else p2->next=p1->next;

printf("delete:%ld\n",num); n=n-1; }

else printf("%ld not been found!\n",num);

end;return(head);}

对链表的插入操作

对链表的插入是指将一个结点插入到一个已有的链表中。

为了能做到正确插入，必须解决两个问题：

①怎样找到插入的位置；

②怎样实现插入。

先用指针变量p0指向待插入的结点，p1指向第一个结点。

将p0->num与p1->num相比较，如果p0->num＞p1-> num ，则待插入的结点不应插在p1所指的结点之前。此时将p1后移，并使p2指向刚才p1所指的结点。

再将p1->num与p0->num比,如果仍然是p0->num大，则应使p1继续后移，直到p0->num ≤p1-> num为止。

这时将p0所指的结点插到p1所指结点之前。但是如果p1所指的已是表尾结点，则p1就不应后移了。如果p0-> num比所有结点的num都大，则应将p0所指的结点插到链表末尾。

如果插入的位置既不在第一个结点之前，又不在表尾结点之后，则将p0的值赋给p2->next，使p2->next指向待插入的结点，然后将p1的值赋给p0->next，使得p0->next指向p1指向的变量。

如果插入位置为第一个结点之前(即p1等于head时)，则将p0赋给head，将p1赋给p0->next 如果要插到表尾之后，应将p0赋给p1->next，NULL赋给p0->next

例插入结点的函数insert如下。

struct student *insert(struct student *head, struct student *stud)

{struct student *p0,*p1,*p2;

p1=head;p0=stud; if(head==NULL)

{head=p0; p0->next=NULL;}

else{while((p0->num>p1->num) && (p1->next!=NULL))

{p2=p1; p1=p1->next;} if(p0->num<=p1->num) {if(head==p1) head=p0;

else p2->next=p0; p0->next=p1;}

else {p1->next=p0; p0->next=NULL;}}

n=n+1; return(head);

}

void main()

{

struct student *head,stu;long del_num;

prinf(″intput records:\n″) ;

head=creat();print(head);

printf (″\n intput the deleted number:\n″);

scanf (″%ld″,&del_num) ;head=del(head,del_num);

print(head);

printf (″\n intput the inserted number:\n″);

scanf (″%ld″,&stu.num,&stu.score) ;

head=insert(head,&stu);

print(head);

}

此程序运行结果是正确的。它只删除一个结点，插入一个结点。

但如果想再插入一个结点，重复写上程序最后4行，共插入两个结点，运行结果却是错误的。

Input records：（建立链表）

10101，９０↙

10103，９８↙

10105，７６↙

０，０↙

Now,these 3 records are：

10１０１９０．０

10１０３９８．０

10１０５７６．０

intput the deleted number ：10103（删除）

ｄｅｌｅｔｅ：10１０３↙

Now,these 2 records are：

10１０１９０．０

10１０５７６．０

input the inserted record （插入第一个结点）

10102，90↙

Now,these 3 records are：

10１０１９０．０

10１０２９０．０

10１０５７６．０

input the inserted record （插入第二个结点）

10104，99↙

Now,these 4 records are：

10１０１９０．０

10１０４９９．０

10１０４９９．０

10１０４９９．０

……………

出现以上结果的原因是：

stu是一个有固定地址的结构体变量。

第一次把stu结点插入到链表中。

第二次若再用它来插入第二个结点，就把第一次结点的数据冲掉了，实际上并没有开辟两个结点。

为了解决这个问题，必须在每插入一个结点时新开辟一个内存区。我们修改main函数，使之能删除多个结点（直到输入要删的学号为0），能插入多个结点（直到输入要插入的学号为0）。

printf("\ninput the inserted record:");

stu=(struct student *) malloc(LEN);

scanf("%ld,%f",&stu->num,&stu->score);

while(stu->num!=0)

{

head=insert(head,stu);

printf("input the inserted record:");

stu=(struct student *)malloc(LEN);

scanf("%ld,%f",&stu->num,&stu->score);

}

} // end of main()

程序说明：

stu定义为指针变量，在需要插入时先用malloc函数开辟一个内存区，将其起始地址经强制类型转换后赋给stu，然后输入此结构体变量中各成员的值。

对不同的插入对象，stu的值是不同的，每次指向一个新的struct student变量。

在调用insert函数时，实参为head和stu，将已建立的链表起始地址传给insert函数的形参，将stu（即新开辟的单元的地址）传给形参stud，返回的函数值是经过插入之后的链表的头指针（地址）

C语言程序设计第二章-常用数据类型

第二章常用数据类型 【学习目标】 本章将学习一些基本的程序概念，如程序结构、标识符、章的学习要 关键字和注释等。本点包括如下几点： （1）了解C语言的基本结构。 （2）分号、块和空白的使用。 （3）标识符的约束规则。 （4）C关键字。 （5 ）直接量的认识。 （6）注释的使用。 【学习导航】 本章的在整个课程中的位置如图2-1所示。 图2-1 本章学习导航

2.1 C语言基本程序结构 任何一种程序设计语言都具有特定的语法规则和规定的表达方法。一个程序只有严格按 照语言规定的语法和表达方式编写，才能保证编写的程序在计算机中能正确地执行，同时也 便于阅读和理解。为了了解C语言的基本程序结构，请看【课堂案例2-1】。 【课堂案例2-1】在控制台输出“你好”。 【案例目标】会使用Xcode编辑器实现字符串输出 【案例知识要点】C语言的程序结构、基本输出语句 【案例程序代码】hello.c 1#i nclude 2 2mai n（） 3{ 4printf（你好”）； 5} 【案例代码说明】 第1行的作用是进行相关的预处理操作。include成为文件包含命令，<>里的内容称为 头文件。头文件一般的扩展名为.ho stdio就是指“ sta ndard in put & output"（标准输入输出），所以，源代码中如用到标准输入输出函数时，就要包含这个头文件。 第2行是一个空行。空行不会影响程序的功能。空行起着分隔程序段落的作用，适当使用空行将使程序的布局更加清晰，提高程序的可读性。空行不会浪费内存，所以不要舍不得 用空行。一般建议在头文件后插入一个空行。 第3行声明了一个main函数，main是函数名。关于函数的详细介绍在第七章。main 函数具有特殊意义，它是程序执行的入口，也就是说，程序都是从main函数开始执行的。 第4—6行定义了main函数的内容，称为函数体。以“{”开始，以“ }”结束。 第5行调用了在stdio.h中的格式化输出函数printf,其作用是向终端（显示器、控制台）输出字符。在这一行结束时，需要加上（；）。在C语言中，一行代码由分号（；）终止。 图2-2是程序hello.c的执行结果： 图2-2 Simple.c程序输出结果 知识链接一编程规范 在hello.c程序中，要注意以下的编程规范： 【规则1-1】用#“clude 格式来引用标准库的头文件。 【规则1-2】包含头文件时一般不使用绝对路径名。 【规则1-3】在头文件和main函数之间使用空行隔开。 【规则1-4】函数体里面的内容（即{ }里面的内容），需要水平缩进四个空格。如第5行所示。hello.c

C语言数据类型习题及答案

第二章数据类型，运算符与表达式 一．选择题 1．不合法的字符常量是（B）。 A）‘\t’B) “A” C）‘a’D）’\x32’ 2、合法的字符常量是（D）。 A）‘\084’B) ‘\84’ C）‘ab’D）’\x43’ 2．（B）是C语言提供的合法的数据类型关键字。 A）Float B）signed C）integer D）Char 3．在以下各组标识符中，合法的标识符是（4）。 （1）A）B01 B）table_1 C）0_t D）k% （2）A）Fast_ B）void C）pbl D） （3）A）xy_ B）longdouble C）*p D）CHAR (4) A) sj B)Int C)_xy D)w_y23 4．属于合法的C语言长整型常量的是（B）。 A）5876273 B）0L C）2E10 D）(long)5876273 5．下面选项中，不是合法整型常量的是（B）。 A）160 B）－0xcdg C）－01 D）－0x48a 6．判断int x = 0xaffbc；x的结果是（B）（turbo c 版本）。 A）赋值非法B）溢出C）为affb D）为ffbc 7．下面选项中，均是合法浮点数的是（B）。 A）＋1e＋1 B）－.60 C）123e D）－e3 A)5e－9.4 B)12e－4 C)1.2e－.4 D).8e－4 A)03e2 B)－8e5 C)＋2e－1 D)5.e－0 8．在C语言中，要求参加运算的数必须是整数的运算符是（C）。A）/ B）* C）% D) = 9．在C语言中，字符型数据在内存中以（D）形式存放。 A）原码B）BCD码C）反码D）ASCII码 10．下列语句中，符合语法的赋值语句是（C）。 A）a＝7＋b＋c＝a+7；B）a＝7＋b＋＋＝a＋7； C）a=(7＋b，b＋＋，a＋7)；D）a＝7＋b，c＝a＋7； 11．（B）是非法的C语言转义字符。 A）‘\b’B）‘\0xf’ C）‘\037’ D）‘\’’ 12．对于语句：f=(3.0,4.0,5.0),(2.0,1.0,0.0);的判断中（B），是正确的。A）语法错误B）f为5.0 C)f为0.0 D）f为2.0 13．与代数式(x*y)/(u*v) 不等价的C语言表达式是（A）。 A）x*y/u*v B）x*y/u/v C）x*y/(u*v) D）x/(u*v)*y 14．在C语言中，数字029是一个（D）。 A）八进制数B）十六进制数C）十进制数D）非法数 15．C语言中（Turbo C环境）整数－8在内存中的存储形式为（A）。A）1111111111111000 B）1000 C）1000 D）1111111111110111 16．对于char cx=’ \039’;语句，正确的是(A)。 A）不合法B）cx的ASCII值是33 C）cx的值为四个字符D）cx的值为三个字符

C语言结构体实验报告

《高级语言程序设计》实验报告实验序号：8 实验项目名称：结构体

附源程序清单： 1. #include struct student { int num; char name[20]; char classname[20]; float score[3]; float aver_score; }stu[5]; void input() { int i; for(i=1;i<6;i++) { printf("第%d个同学",i); printf("请输入学号名字班级三门课程成绩:\n"); scanf("%d %s %s %f %f %f",&stu[i].num,stu[i].name,stu[i].classname,&stu[i].score[1],&stu [i].score[2],&stu[i].score[3]); } }; void averagescore() {

for(i=1;i<=5;i++) stu[i].aver_score=((stu[i].score[1]+stu[i].score[2]+stu[i].score[3])/3); printf("平均成绩:"); for(i=1;i<6;i++) printf("第%d个同学的平均成绩%f:\n",i,stu[i].aver_score); printf("\n"); }; void max() { int i,k=0; float temp=stu[1].aver_score; for(i=2;i<=5;i++) if(stu[i].aver_score>temp) {temp=stu[i] .aver_score;k=i;}; printf("成绩最好的同学:\n"); printf("%d %s %s %4.2f %4.2f %4.2f %4.2f\n", stu[k].num,stu[k].name,stu[k].classname,stu[k].score[1],stu[k].score[2],stu[k].score[3],stu[k].aver _score); }; void main() { input(); averagescore(); max(); } 2.#include struct worker { char name[20]; int workyear; float salary; }work[5]; void input() { int i; for(i=1;i<=5;i++) { printf("第%d个工人:",i); printf("请输入名字工作年限工资总额:\n"); scanf("%s %d %f",&work[i].name,&work[i].workyear,&work[i].salary);

C语言第二章习题带答案

1．C语言中的简单数据类型包括( B )。 A．整型、实型、逻辑型B．整型、实型、字符型 C．整型、字符型、逻辑型D．整型、实型、逻辑型、字符型2．在C语言中，错误的short类型的常数是( A )。 A．32768 B．0 C．037 D．0Xaf 3．下列常数中不能作为C的常量的是( D )。 A．0x45 B．2.5e-2 C．3e2 D．0582 4．short类型的数据长度为2个字节，则unsigned short类型数据的取值范围是( B )。 A．0至255 B．0~65535 C．-32768~32767 D．-256~255 5．下面4个选项中，均是合法转义字符的选项是( A )。 A．'\''，'\\'，'\n' B．'\'，'\017'，'\' C．'\018'，'\f'，'xab' D．'\\0，'101'，'x1f 6．在C语言中，数字029是一个( D )。 A．八进制数B．十六进制数 C.十进制数D．非法数 7．下列可以正确表示字符型常数的是( B )。 A．"a" B．'\t' C．"\n" D．297 8．以下( C )是错误的转义字符。 A．'\\' B．'\'' C．'\81' D．'\0' 9．C语言中short类型的变量a的值为-8，则a在内存中的存储形式是( A )。 A．1111 1111 1111 1000 B．100000000000 1000 C．000000000000 1000 D．1111 1111 1111 0111 10．将字符g赋给字符变量c，正确的表达式是( C )。 A．c="g" B．c=101 C．c='\147' D．c='0147' 11．字符串"\\\22a,0\n"的长度是( C )。 A．8 B．7 C．6 D．5 12．为求出s=10!的值，则变量s的类型应当为( C )。 A．short B．unsigned short C．long D．以上三种类型均可13．已知：unsigned short x=65535;，则执行以下语句输出是( D )。 printf("%d\n", x)； A．65535 B．1 C．无定值D．-1 14．下面4个选项中，均是合法整型常量的选项是( A )。 A．160，-0xffff，011 B．-0xcdf，01a，0xe C．-01，986，012，0668 D．-0x48a，2e5，0x 15．下面4个选项中，均是不合法的整型常量的选项是( D )。 A．--0f1，-0xffff，0011 B．-0Xcdf，01a，0xe C．-018，999，5e2 D．-0x48eg，-068，03f 16．下面4个选项中，均是合法浮点数的选项是( B )。 A．+1e+1，5e-9.4，03e2 B．-.60，12e-4，-8e5 C．123e，1.2e-.4，+2e-1 D．-e3，.8e-4，5.e-0

C语言第三章数据类型和运算符及表达式复习题

数据类型、运算符和表达式复习题一．选择题 1. 以下不合法的用户标识符是：（） a) f2_G3 b) If c) 4d d) _8 2. 以下选项中合法的用户标识符是：（） a) long b) _2Test c) 3Dmax d) A.dat 3. 以下可用作用户标识符的是：（） a) 12_a b) signed c) t-o d) _if 4. 以下不是关键字的标识符是：（） a) continue b) char c) If d) default 5. C语言提供的合法的关键字是：（） a) swicth b) cher c) Case d) void 6. 以下选项中不合法的int整型常数是（） a) 32768 b) -56 c) 03 d) 0xAF 7. 以下合法的长整型常量是（） a) 2L b) 49627 c) d) 213& 8. 以下正确的实型常量是（） a) 1.2E b) . c) 1.2e0.6 d) 8 9. 以下选项中合法的实型常数是（） a) 5E2.0 b) E-3 c) .2E0 d) 1.3E 10. 以下合法的八进制数是（） a) 0135 b) 068 c) 013.54 d) o7 11. 以下合法的十六进制数是（） a) 0x b) 0x4de c) 0x1h d) ox77 12. 以下选项中非法的数值常量是（） a) 019 b) 0L c) 0xff d) 1e1 13. 若变量已正确定义，以下合法的赋值表达式是（） a) a=1/b=2 b) ++(a+b) c) a=a/(b=5) d) y=int(a)+b 14. 若变量已正确定义，以下非法的表达式是（） a) a/=b+c b) a%(4.0) c) a=1/2*(x=y=20,x*3) d) a=b=c 15. 设x为int类型，其值为11，则表达式（x++*1/3）的值是： a) 3 b) 4 c) 11 d) 12 16．设a,b均为double型，且a=5.5;b=2.5;则表达式 (int)a+b/b的值是（） a) 6. b) 6 c) 5. d) 6. 17．若a为int型，且其值为3，则执行完表达式： a+=a-=a*a后，a的值是（） a) -3 b) 9 c) -12 d) 6 18．设k和x均为int型变量，且k=7；x=12；则能使 值为3的表达式是（） a) x%=(k%=5) b) x%=(k-k%5) c) x%=k-k%5 d) (x%=k)-(k%=5)

《明解C语言》第2章 运算和数据类型练习题答案

【个人观点】 练习2-1 #include int main(void) { int no1,no2; printf("请输入两个整数："); scanf("%d%d",&no1,&no2); printf("前者是后者的%.0f%%\n",((double)no1/ no2) * 100); return (0); } 【note】（1）no1/ no2是整数，因此要对其中一个浮点化，使得该结果为小数；（2）((double)no1/ no2) * 100的结果是：小数点后的位数为0 练习2-2 #include int main(void) { int vx,vy; puts("请输入两个整数。"); printf("整数vx：");scanf("%d",&vx); printf("整数vy：");scanf("%d",&vy); printf("它们的和是%d，积是%d\n",vx + vy,vx * vy); return (0); } 练习2-3 #include int main(void) { double no; puts("请输入一个实数："); scanf("%lf",&no); 1

printf("您输入的实数是%f\n",no); return (0); } 练习2-4 #include int main(void) { int n1,n2,n3,n4; double d1,d2,d3,d4; n1 = 5 / 2; n2 = 5.0 / 2.0; n3 = 5.0 / 2; n4 = 5 / 2.0; d1 = 5 / 2; d2 = 5.0 / 2.0; d3 = 5.0 / 2; d4 = 5 / 2.0; printf("n1 = %d\n",n1); printf("n2 = %d\n",n2); printf("n3 = %d\n",n3); printf("n4 = %d\n",n4); printf("d1 = %f\n", d1); printf("d2 = %f\n",d2); printf("d3 = %f\n",d3); printf("d4 = %f\n",d4); return (0); } 练习2-5 #include int main(void) { int no1,no2; printf("请输入两个整数："); 2

C语言的基本数据类型及其表示

3.2 C语言的基本数据类型及其表示 C语言的基本数据类型包括整型数据、实型数据和字符型数据，这些不同数据类型如何表示？如何使用？它们的数据范围是什么？下面我们分别进行介绍。 3.2.1 常量与变量 1. 常量 常量是指程序在运行时其值不能改变的量，它是Ｃ语言中使用的基本数据对 象之一。Ｃ语言提供的常量有： 以上是常量所具有的类型属性，这些类型决定了各种常量所占存储空间的大小和数的表示范围。在C程序中，常量是直接以自身的存在形式体现其值和类型，例如：123是一个整型常量，占两个存储字节，数的表示范围是-32768～32767；123.0是实型常量，占四个存储字节，数的表示范围是-3.4 10-38～3.4 1038。 需要注意的是，常量并不占内存，在程序运行时它作为操作对象直接出现在运算器的各种寄存器中。 2.符号常量 在C程序中，常量除了以自身的存在形式直接表示之外，还可以用标识符来表示常量。因为经常碰到这样的问题：常量本身是一个较长的字符序列，且在程序中重复出现，例如：取常数的值为3.1415927，如果在程序中多处出现，直接使用3.1415927的表示形式，势必会使编程工作显得繁琐，而且，当需要把的值修改为3.1415926536时，就必须逐个查找并修改，这样，会降低程序的可修改性和灵活性。因此，Ｃ语言中提供了一种符号常量，即用指定的标识符来表示某个常量，在程序中需要使用该常量时就可直接引用标识符。 Ｃ语言中用宏定义命令对符号常量进行定义，其定义形式如下： #define 标识符常量 其中#define是宏定义命令的专用定义符，标识符是对常量的命名，常量可以是前面介绍的几种类型常量中的任何一种。该使指定的标识符来代表指定的常量，这个被指定的标识符就称为符号常量。例如，在C程序中，要用PAI代表实型常量3.1415927，用W代表字符串常量"Windows 98"，可用下面两个宏定义命令： #define PAI 3.1415927 #define W "Windows 98" 宏定义的功能是：在编译预处理时，将程序中宏定义（关于编译预处理和宏定义的概念详见9.10节）命令之后出现的所有符号常量用宏定义命令中对应的常量一一替代。例如，对于以上两个宏定义命令，编译程序时，编译系统首先将程序中除这两个宏定义命令之外的所有PAI替换为3.1415927，所有W替换为Windows 98。因此，符号常量通常也被称为宏替换名。 习惯上人们把符号常量名用大写字母表示，而把变量名用小写字母表示。例3-1是符号常量的一个简单的应用。其中，PI为定义的符号常量，程序编译时，用3.1416替换所有的PI。 例3-1：已知圆半径r，求圆周长c和圆面积s的值。

C语言数据类型及表示范围

C语言各种数据类型在系统中占的字节和取值围 基本类型包括字节型（char）、整型（int）和浮点型（float/double）。 定义基本类型变量时，可以使用符号属性signed、unsigned（对于char、int），和长度属性short、long（对于int、double）对变量的取值区间和精度进行说明。 下面列举了Dev-C++下基本类型所占位数和取值围： 符号属性长度属性基本型所占位数取值围输入符举例输出符举例-- -- char 8 -2^7 ~ 2^7-1 %c %c、%d、%u signed -- char 8 -2^7 ~ 2^7-1 %c %c、%d、%u unsigned -- char 8 0 ~ 2^8-1 %c %c、%d、%u [signed] short [int] 16 -2^15 ~ 2^15-1 %hd unsigned short [int] 16 0 ~ 2^16-1 %hu、%ho、%hx [signed] -- int 32 -2^31 ~ 2^31-1 %d unsigned -- [int] 32 0 ~ 2^32-1 %u、%o、%x [signed] long [int] 32 -2^31 ~ 2^31-1 %ld unsigned long [int] 32 0 ~ 2^32-1 %lu、%lo、%lx [signed] long long [int] 64 -2^63 ~ 2^63-1 %I64d unsigned long long [int] 64 0 ~ 2^64-1 %I64u、%I64o、%I64x -- -- float 32 +/- 3.40282e+038 %f、%e、%g -- -- double 64 +/- 1.79769e+308 %lf、%le、%lg %f、%e、%g -- long double 96 +/- 1.79769e+308 %Lf、%Le、%Lg 几点说明： 1. 注意! 表中的每一行，代表一种基本类型。“[]”代表可省略。 例如：char、signed char、unsigned char是三种互不相同的类型； int、short、long也是三种互不相同的类型。可以使用C++的函数重载特性进行验证，如: void Func(char ch) {} void Func(signed char ch) {} void Func(unsigned char ch) {} 是三个不同的函数。

c语言第三、四章(习题册答案)

第三章数据类型、运算符和表达式 一、选择题： 1、以下选项中，不正确的C 语言浮点型常量是（C）。 A. 160. B. 0.12 C. 2e4.2 D. 0.0 2、以下选项中，（D）是不正确的C 语言字符型常量。 A. 'a' B. '\x41' C. '\101' D. "a" 3、在C 语言中，字符型数据在计算机内存中，以字符的（C）形式存储。 A. 原码 B. 反码 C. ASCII 码 D. BCD码 4、若x、i、j和k都是int型变量，则计算下面表达式后，x的值是（C）。 x=（i=4，j=16，k=32） A. 4 B. 16 C.32 D.52 5、算术运算符、赋值运算符和关系运算符的运算优先级按从高到低依次为(B)。 A. 算术运算、赋值运算、关系运算 B. 算术运算、关系运算、赋值运算 C. 关系运算、赋值运算、算术运算 D. 关系运算、算术运算、赋值运算 6、表达式!x||a==b 等效于(D)。 A. !((x||a)==b) B. !(x||y)==b C. !(x||(a==b)) D. (!x)||(a==b) 7、设整型变量m,n,a,b,c,d 均为1，执行(m=a>b)&&(n=c>d)后, m,n 的值是（B）。 A. 0，0 B. 0，1 C. 1，0 D. 1，1 8、设有语句int a=3；，则执行了语句a+=a-=a*=a;后，变量a 的值是(B)。 A. 3 B. 0 C. 9 D. -12 9、在以下一组运算符中，优先级最低的运算符是(D)。 A. * B. != C. + D. = 10、设整型变量i 值为2，表达式(++i)+(++i)+(++i)的结果是(B)。 A. 6 B. 12 C. 15 D. 表达式出错 11、若已定义x 和y为double 类型，则表达式x=1，y=x+3/2 的值是(C)。 A. 1 B. 2 C. 2.0 D. 2.5 12、设a=1，b=2，c=3，d=4，则表达式：a10 && a<15 D. !(a<=10) && !(a>=15) 14、设f是实型变量，下列表达式中不是逗号表达式的是(D)。 A. f= 3.2, 1.0 B. f>0, f<10 C. f=2.0, f>0 D. f=(3.2, 1.0) 15、表达式18/4*sqrt(4.0)/8值的数据类型是（C）。 A. int B. float C. double D. 不确定 16、已知字母A的ASCII码为十进制数65，且c2为字符型，则执行语句 C2=’A’+’6’-‘3’;后c2中的值是（A）。 A. D B. 68 C. 不确定的值 D. C 17、以下用户标识符中，合法的是（B）。 A. int B. nit C. 123 D. a+b 18、C 语言中，要求运算对象只能为整数的运算符是（A）。

C语言结构体(struct)常见使用方法

C语言结构体（struct）常见使用方法 基本定义：结构体，通俗讲就像是打包封装，把一些有共同特征（比如同属于某一类事物的属性，往往是某种业务相关属性的聚合）的变量封装在内部，通过一定方法访问修改内部变量。 结构体定义： 第一种：只有结构体定义 [cpp]view plain copy 1.struct stuff{ 2.char job[20]; 3.int age; 4.float height; 5.}; 第二种：附加该结构体类型的“结构体变量”的初始化的结构体定义 [cpp]view plain copy 1.//直接带变量名Huqinwei 2.struct stuff{ 3.char job[20]; 4.int age; 5.float height; 6.}Huqinwei; 也许初期看不习惯容易困惑，其实这就相当于： [cpp]view plain copy 1.struct stuff{ 2.char job[20]; 3.int age;

4.float height; 5.}; 6.struct stuff Huqinwei; 第三种：如果该结构体你只用一个变量Huqinwei，而不再需要用 [cpp]view plain copy 1.struct stuff yourname; 去定义第二个变量。 那么，附加变量初始化的结构体定义还可进一步简化出第三种： [cpp]view plain copy 1.struct{ 2.char job[20]; 3.int age; 4.float height; 5.}Huqinwei; 把结构体名称去掉，这样更简洁，不过也不能定义其他同结构体变量了——至少我现在没掌握这种方法。 结构体变量及其内部成员变量的定义及访问： 绕口吧？要分清结构体变量和结构体内部成员变量的概念。 就像刚才的第二种提到的，结构体变量的声明可以用： [cpp]view plain copy 1.struct stuff yourname; 其成员变量的定义可以随声明进行： [cpp]view plain copy 1.struct stuff Huqinwei = {"manager",30,185}; 也可以考虑结构体之间的赋值： [cpp]view plain copy

c语言结构体指针初始化===

c语言结构体指针初始化 今天来讨论一下C中的内存管理。 记得上周在饭桌上和同事讨论C语言的崛起时，讲到了内存管理方面 我说所有指针使用前都必须初始化，结构体中的成员指针也是一样 有人反驳说，不是吧，以前做二叉树算法时，他的左右孩子指针使用时难道有初始化吗 那时我不知怎么的想不出理由，虽然我还是坚信要初始化的 过了几天这位同事说他试了一下，结构体中的成员指针不经过初始化是可以用（左子树和右子树指针） 那时在忙着整理文档，没在意 今天抽空调了一下，结论是，还是需要初始化的。 而且，不写代码你是不知道原因的（也许是对着电脑久了IQ和记性严重下跌吧） 测试代码如下 1.#include 2.#include 3.#include 4. 5.struct student{ 6.char *name; 7.int score; 8.struct student* next; 9.}stu,*stu1; 10. 11.int main(){ 12. https://www.sodocs.net/doc/2a10165120.html, = (char*)malloc(sizeof(char)); /*1.结构体成员指针需要初始化*/ 13. strcpy(https://www.sodocs.net/doc/2a10165120.html,,"Jimy"); 14. stu.score = 99; 15. 16. stu1 = (struct student*)malloc(sizeof(struct student));/*2.结构体指针需要初始化*/ 17. stu1->name = (char*)malloc(sizeof(char));/*3.结构体指针的成员指针同样需要初始化*/ 18. stu.next = stu1; 19. strcpy(stu1->name,"Lucy"); 20. stu1->score = 98; 21. stu1->next = NULL; 22. printf("name %s, score %d \n ",https://www.sodocs.net/doc/2a10165120.html,, stu.score); 23. printf("name %s, score %d \n ",stu1->name, stu1->score); 24. free(stu1); 25.return 0; 26.} #include #include #include struct student{ char *name; int score; struct student* next; }stu,*stu1; int main(){ https://www.sodocs.net/doc/2a10165120.html, = (char*)malloc(sizeof(char)); /*1.结构体成员指针需要初始化*/ strcpy(https://www.sodocs.net/doc/2a10165120.html,,"Jimy"); stu.score = 99; stu1 = (struct student*)malloc(sizeof(struct student));/*2.结构体指针需要初始化*/ stu1->name = (char*)malloc(sizeof(char));/*3.结构体指针的成员指针同样需要初始化*/ stu.next = stu1; strcpy(stu1->name,"Lucy"); stu1->score = 98; stu1->next = NULL; printf("name %s, score %d \n ",https://www.sodocs.net/doc/2a10165120.html,, stu.score);

C语言基本数据类型及运算题库

第二章基本数据类型及运算 一、选择题 1. 若以下选项中的变量已正确定义，则正确的赋值语句是。 A) x1=26.8%3; B) 1+2=x2; C) x3=0x12; D) x4=1+2=3; 答案：C 2. 设变量x为float型且已经赋值，则以下语句中能够将x中的数值保留到小数点后面两位，并将第三位四舍五入的是。 A) x=x*100+0.5/100.0 B) x=(x*100+0.5)/100.0 C) x=(int)(x*100+0.5)/100.0 D) x=(x/100+0.5)*100.0 答案：C 3. 下列C语言中运算对象必须是整型的运算符是。 A) %= B) / C) = D) *= 答案：A 4. 若有以下程序段：int c1=1,c2=2,c3;c3=1.0/c2*c1;则执行后，c3中的值是。 A) 0 B) 0.5 C) 1 D) 2 答案：A 5. 设x和y均为int型变量，则以下语句：x+=y; y=x-y; x-=y; 的功能是。 A) 把x和y按从大到小排列 B) 把x和y按从小到大排列 C) 无确定结果 D) 交换x和y中的值 答案：D 6. 下列变量定义中合法的是。 A）short_a=1-.le-1; B）double b=1+5e2.5; C）long do=0xfdaL; D）float 2_and=1-e-3; 答案：A 7. 以下4个选项中，不能被看作是一条语句的是。 A) {；} B) a=0,b=0,c=0; C) if (a>0); D) if (b==0)m=1;n=2; 答案：D 8. 设x=1,y=-1，下列表达式中解为8的是。 A）x&y B）~x│x C）x＾x D）x<<=3 答案：D 9. 在C语言中不合法的整数是。 A）20 B）0x4001 C）08 D）0x12ed 答案： C 10. 以下选项中不正确的实型常量是 A）2.607E-1 B)0.8103e0.2 C)-77.77 D)456e –2 答案：B） 11.若变量已正确定义并赋值，符合C语言语法的表达式是 A）a=a+7 B）a=7+b+c,a++ C）int(12.3%4) D）a=a+7=c+b 答案：B） 12.以下十六进制数中不合法的是 A）oxff B）0Xabc C）0x11 D）0x19

二级C语言结构体定义及应用部分练习题(十三)(精)

（1）有以下程序段 typedef struct NODE { int num; struct NODE *next; } OLD; 以下叙述中正确的是C A）以上的说明形式非法 B）NODE是一个结构体类型 C）OLD是一个结构体类型 D）OLD是一个结构体变量（2）若有以下说明和定义union dt { int a; char b; double c; }data; 以下叙述中错误的是 C A）data的每个成员起始地址都相同 B）变量data所占内存字节数与成员c所占字节数相等 C）程序段：data.a=5;printf（"%f\n",data.c）;输出结果为5.000000 D）data可以作为函数的实参（3）设有如下说明 typedef struct ST { long a; int b; char c[2]; } NEW; 则下面叙述中正确的是 C A）以上的说明形式非法 B）ST是一个结构体类型 C）NEW是一个结构体类型 D）NEW是一个结构体变量（4）以下对结构体类型变量td的定义中，错误的是 C 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; （5）设有以下语句 typedef struct S { int g; char h;} T; 则下面叙述中正确的是B A）可用S定义结构体变量 B）可以用T定义结构体变量 C）S是struct类型的变量 D）T是struct S类型的变量（6）设有如下说明 typedef struct { int n; char c; double x;}STD; 则以下选项中，能正确定义结构体数组并赋初值的语句是B 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}}; （7）设有以下说明语句 typedef struct { int n; char ch[8]; }PER; 则下面叙述中正确的是B A） PER 是结构体变量名 B） PER是结构体类型名 C） typedef struct 是结构体类型 D）struct 是结构体类型名（8）设有以下说明语句 struct ex { int x ; float y; char z ;} example; 则下面的叙述中不正确的是B A） struct结构体类型的关键字 B）example是结构体类型名 C） x,y,z都是结构体成员名 D） struct ex是结构体类型（9）有如下定义 struct person{char name[9]; int age;}; strict person class[10]={“Johu”, 17, “Paul”, 19 “Mary”, 18, “Adam 16,}; 根据上述定义，能输出字母M的语句是D A） prinft（“%c\n”,class[ 3].mane）; B） pfintf（“%c\n”,class[3].name[1]）; C） prinft （“%c\n”,class[2].n ame[1]）; D） printf（“%^c\n”,class[2].name[0]）; （10）变量a

C语言中结构体的使用

脚踏实地，心无旁骛，珍惜分分秒秒。紧跟老师，夯实基础。 什么是结构体？ 简单的来说 结构体就是一个可以包含不同数据类型的一个结构 它是一种可以自己定义的数据类型 它的特点和数组主要有两点不同 首先结构体可以在一个结构中声明不同的数据类型 第二相同结构的结构体变量是可以相互赋值的 而数组是做不到的 因为数组是单一数据类型的数据集合 它本身不是数据类型(而结构体是) 数组名称是常量指针 所以不可以做为左值进行运算 所以数组之间就不能通过数组名称相互复制了 即使数据类型和数组大小完全相同 定义结构体使用struct修饰符 例如： struct test { float a; int b; }; 上面的代码就定义了一个名为test的结构体 它的数据类型就是test 它包含两个成员a和b 成员a的数据类型为浮点型 成员b的数据类型为整型 由于结构体本身就是自定义的数据类型 定义结构体变量的方法和定义普通变量的方法一样 test pn1; 这样就定义了一test结构体数据类型的结构体变量pn1 结构体成员的访问通过点操作符进行 pn1.a=10 就对结构体变量pn1的成员a进行了赋值操作 注意:结构体生命的时候本身不占用任何内存空间 只有当你用你定义的结构体类型定义结构体变量的时候计算机才会分配内存

结构体 同样是可以定义指针的 那么结构体指针就叫做结构指针 结构指针通过->符号来访问成员 下面我们就以上所说的看一个完整的例子： #include #include using namespace std; struct test//定义一个名为test的结构体 { int a;//定义结构体成员a int b;//定义结构体成员b }; void main() { test pn1;//定义结构体变量pn1 test pn2;//定义结构体变量pn2 pn2.a=10;//通过成员操作符.给结构体变量pn2中的成员a赋值 pn2.b=3;//通过成员操作符.给结构体变量pn2中的成员b赋值 pn1=pn2;//把pn2中所有的成员值复制给具有相同结构的结构体变量pn1 cout<a=99;//通过结构指针修改结构体变量pn2成员a的值 cout<a<<"|"<b<

C语言基本数据类型简介

C语言基本数据类型简介 1.概述 C 语言包含的数据类型如下图所示： 2.各种数据类型介绍 2.1整型 整形包括短整型、整形和长整形。 2.1.1短整形 short a=1; 2.1.2整形 一般占4个字节（32位），最高位代表符号，0表示正数，1表示负数，取值围是 -2147483648~2147483647，在存中的存储顺序是地位在前、高位在后，例如0x12345678在存中的存储如下： 地址：0x0012ff780x0012ff790x0012ff7a0x0012ff7b 数据：78563412 定义：用int关键字，举例如下： int a=6; 2.1.3长整形 long a=10; 2.2浮点型 浮点型包括单精度型和双精度型。 2.2.1单精度型 浮点型，又称实型，也称单精度。一般占4个字节（32位）， float a=4.5; 地址：0x0012ff780x0012ff790x0012ff7a0x0012ff7b 数据：00009040 2.2.2双精度型 一般占8个字节（64位） double a=4.5;

地址：0x0012ff780x0012ff790x0012ff7a0x0012ff7b0x0012ff7c 0x0012ff7d0x0012ff7e0x0012ff7f 数据：0000000000 001240 2.3字符类型 在各种不同系统中，字符类型都占一个字节（8位）。定义如下： char c='a'; 也可以用字符对应的ASCII码赋值，如下： char c=97; 3.数据类型与“模子” short、int、long、char、float、double 这六个关键字代表C 语言里的六种基本数据类型。 怎么去理解它们呢? 举个例子：见过藕煤球的那个东西吧？(没见过？煤球总见过吧)。那个东西叫藕煤器，拿着它在和好的煤堆里这么一咔，一个煤球出来了。半径12cm，12 个孔。不同型号的藕煤器咔出来的煤球大小不一样，孔数也不一样。这个藕煤器其实就是个模子。 现在我们联想一下，short、int、long、char、float、double 这六个东东是不是很像不同类型的藕煤器啊？拿着它们在存上咔咔咔，不同大小的存就分配好了，当然别忘了给它们取个好听的名字。 在32 位的系统上 short 短整型的存2 byte； int 整型的存4 byte； long 长整型的存4 byte； float 单精度浮点型的存4byte；仅能接收7位有效数字 double 双精度浮点型的存8 byte；可以接收16位有效数字 char字符型的存1 byte。 fabs单精度浮点型存4byte. （注意这里指一般情况，可能不同的平台还会有所不同，具体平台可以用sizeof 关键字测试一下） 很简单吧？咔咔咔很爽吧？是很简单，也确实很爽，但问题就是你咔出来这么多存块，你总不能

C语言基本数据类型及运算题库1

基本数据类型及运算 一、选择题 1.若以下选项中的变量已正确定义，则正确的赋值语句是。 A)x1=26.8%3;B)1+2=x2;C)x3=0x12;D)x4=1+2=3; 答案：C 2.设变量x为float型且已经赋值，则以下语句中能够将x中的数值保留到小数点后面两位，并将第三位四舍五入的是。 A)x=x*100+0.5/100.0B)x=(x*100+0.5)/100.0 C)x=(int)(x*100+0.5)/100.0D)x=(x/100+0.5)*100.0 答案：C 3.下列C语言中运算对象必须是整型的运算符是。 A)%=B)/C)=D)*= 答案：A 4.若有以下程序段：int c1=1,c2=2,c3;c3=1.0/c2*c1;则执行后，c3中的值是。 A)0B)0.5C)1D)2 答案：A 5.设x和y均为int型变量，则以下语句：x+=y;y=x-y;x-=y;的功能是。 A)把x和y按从大到小排列B)把x和y按从小到大排列 C)无确定结果D)交换x和y中的值 答案：D 6.下列变量定义中合法的是。 A）short_a=1-.le-1;B）double b=1+5e2.5; C）long do=0xfdaL;D）float2_and=1-e-3; 答案：A 7.以下4个选项中，不能被看作是一条语句的是。 A){；}B)a=0,b=0,c=0; C)if(a>0);D)if(b==0)m=1;n=2; 答案：D 8.设x=1,y=-1，下列表达式中解为8的是。 A）x&y B）~x│x C）x＾x D）x<<=3 答案：D 9.在C语言中不合法的整数是。 A）20B）0x4001C）08D）0x12ed 答案：C 10.以下选项中不正确的实型常量是 A）2.607E-1B)0.8103e0.2C)-77.77D)456e–2 答案：B） 11.若变量已正确定义并赋值，符合C语言语法的表达式是 A）a=a+7B）a=7+b+c,a++ C）int(12.3%4)D）a=a+7=c+b 答案：B） 12.以下十六进制数中不合法的是 A）oxff B）0Xabc C）0x11D）0x19