C语言 结构体和共用体文档格式.docx

C语言 结构体和共用体文档格式.docx

《C语言 结构体和共用体文档格式.docx》由会员分享，可在线阅读，更多相关《C语言 结构体和共用体文档格式.docx（14页珍藏版）》请在冰豆网上搜索。

或

struct

（4）结构体类型的变量一般不可以整体引用，通常应该引用其每一个成员（相当于同类型的普通变量）

（5）同类型的结构体变量之间可以整体赋值。

除此之外，不可以整体引用。

（6）结构体变量成员的表示：

结构体变量名.成员名

其中“.”是成员运算符，优先级最高。

2、结构体变量的获值

（1）初始化

structSTUx={“Zhangsan”,‘m’,19,550.5};

（2）定义之后获值

①赋值语句

structSTUx；

strcpy（x.name,“Zhangsan”）;

x.sex=’m’;

x.age=19;

x.score=550.5;

②输入语句

gets（x.name）;

scanf（“%c%d%f”,&

x.sex,&

x.age,&

x.score）;

【注意：

结构体变量所占内存空间的大小是其所有成员所占空间之和。

】

3、结构体的引入就是为了处理表格数据，因此通常定义成结构体数组。

例1：

P287例题（唱票）

#defineN100

#include<

stdio.h>

main（）

{structSTU

intcount;

}s[3]={{"

ZS"

0},{"

LS"

WW"

0}};

inti,j;

charxm[20];

for（j=1;

j<

=N;

j++）

{gets（xm）;

for（i=0;

i<

3;

i++）

if（strcmp（xm,s[i].name）==0）

s[i].count++;

}

printf（"

%4s%4d\n"

s[i].name,s[i].count）;

}

例2：

有5位同学，请按分数降序排列。

#defineN5

}s[N];

structSTUt;

N;

scanf（"

%s%f"

s[i].name,&

s[i].score）;

=N-1;

=N-1-j;

if（s[i].score<

s[i+1].score）

{t=s[i];

s[i]=s[i+1];

s[i+1]=t;

%5s%5.1f\n"

s[i].name,s[i].score）;

读入的结构体变量含有字符串成员时，格式符用空格分隔；

或两类型数据分开读入：

for（i=0;

gets（s[i].name）;

%f"

&

二、指向结构体的指针

1、定义

结构体类型名*指针变量名；

例如：

}；

structSTU*p;

structSTUx;

p=&

x;

于是，x的两个成员可以这样表示：

（*p）.name和（*p）.score

pname和pscore

（1）“”指向运算符由减号-和大于符号>

组合而成，优先级最高。

（2）含义：

pscore

P所指向的结构体变量x的score成员。

（3）以下3种写法完全等价：

x.score、（*p）.score、pscore

3、指向结构体数组（一维）的指针

}a[3],*p；

p=a;

/*p=&

a[0]*/

则p+1指向a[1]，而不是a[0]的第二个成员。

三、单向链表

【补充】

1、数组元素的插入

此算法一般是在已经有序的数组中再插入一个数据，使数组中的数列依然有序。

算法要领是：

假设待插数据为x，数组a中数据为升序序列。

①先将x与a数组当前最后一个元素进行比较，若比最后一个元素还大，就将x放入其后一个元素中；

否则进行以下步骤；

②先查找到待插位置。

从数组a的第1个元素开始找到不比x小的第一个元素，设其下标为i；

③将数组a中原最后一个元素至第i个元素依次一一后移一位，让出待插数据的位置，即下标为i的位置；

④将x存放到a（i）中。

任意读入一个数，往已按升序排列的数组中插入，使之依然有序。

{inta[N+1]={5,8,15,26,39};

/*因为要再插入一个，所以空间多定义一个*/

intx;

%d"

x）;

if（x>

=a[N-1]）

a[N]=x;

else

/*查找待插位置*/

{i=0;

while（x>

a[i]）i++;

/*往第一个比x小的元素之前插*/

/*待插位置的下标是：

i*/

/*从待插位置到最后一个元素倒过来一一后退一位*/

for（j=N-1;

j>

=i;

j--）

a[j+1]=a[j];

/*往待插位置a[i]上插入x*/

a[i]=x;

N+1;

%4d"

a[i]）;

2、数组元素的删除

此算法的要领是：

首先要找到（也可能找不到）待删除元素在数组中的位置（即下标），然后将待删元素后的每一个元素向前移动一位，最后将数组元素的个数减1再输出。

例1、数组a中有若干不同考试分数，任意读入一个分数，若与数组a中某一元素值相等，就将该元素删除。

#defineN6

{intfs[N]={69,90,85,56,44,80},x;

inti,j,n;

n=N;

/*任意读入一个分数值*/

/*以下查找待删分数的位置，即元素下标*/

n;

if（fs[i]==x）break;

if（i==n）printf（"

Notfound!

\n"

）;

else

/*将待删位置之后的所有元素一一前移*/

{for（j=i+1;

j++）fs[j-1]=fs[j];

n=n-1;

/*元素个数减1*/

i++）printf（"

%d"

fs[i]）;

3、单向链表

链表是一种最常见的数据结构，它动态地进行存储分配。

在处理“插入”等问题时，比数组具有优势，因为数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。

当数据增加时，可能超出原先定义的元素个数；

当数据减少时，造成内存浪费。

链表有单向链表、双向链表、循环链表等形式，只需掌握单向链表。

单向链表的特点是：

表上每一个结点都包含两大部分，一是用户需要用的实际数据，二是一个指针，指向下一个结点；

单向链表必须有一个“头指针”，它指向链表的第一个结点，这样才能访问到表上的每一个结点。

4、几个相关库函数

#include“stdlib.h”

（1）结点存储区的动态申请和释放函数

①void*malloc（unsignedintsize）

在动态存储区分配大小为size的连续空间，并返回该空间的地址，赋值给链表结点指针，注意要进行强制类型转换；

若分配失败，则返回NULL。

（空地址值，与0和’\0’等值）

②void*calloc（unsignedintn,unsignedintsize）

在动态存储区分配n个长度为size的连续空间，并返回该空间的地址。

③voidfree（void*ptr）

释放指针ptr指向的内存空间，ptr必须是malloc（）或calloc（）函数返回的值。

例子：

两数交换，借助的第三数动态生成。

#include"

stdlib.h"

{inta,b;

int*p;

%d%d"

a,&

b）;

p=（int*）malloc（sizeof（int））;

*p=a;

a=b;

b=*p;

free（p）;

%d,%d\n"

a,b）;

（2）NULL是空地址值，是系统提供的符号常量，使用时也应该加头文件“stdlib.h”

（3）sizeof是单目运算符，使用格式：

sizeof（类型名）

运算结果是正整数，即所求类型变量占据的内存大小。

5、链表基本操作

下面以例子说明链表的基本操作：

（1）顺序建立链表、逆序建立链表；

（2）链表的遍历（查找）与输出；

（3）插入一个结点；

（4）删除一个结点。

假设想创建如下链表：

注意，链表上的结点按学号升序排列：

1012000411304

head

stdio.h"

{longnum;

structSTU*next;

};

/*只有成员为指针型时，才可以用正在定义的类型名*/

intn;

/*全局变量，结点个数*/

structSTU*nxcreate（）/*逆序建表*/

{structSTU*head,*p;

n=0;

head=NULL;

p=（structSTU*）malloc（sizeof（structSTU））;

\nInputthenode'

snumber,numis0stop\n"

/*让链表上的结点按学号升序排列*/

%ld%f"

p->

num,&

score）;

while（p->

num!

=0）

/*用学号来控制结点个数，为0则终止建表*/

{n=n+1;

p->

next=head;

head=p;

/*以上两句不能颠倒*/

return（head）;

/*输出链表各结点上的有效信息（遍历）*/

voidprint（structSTU*head）

{structSTU*p;

p=head;

while（p!

=NULL）/*

（1）开始就不是空表*/

/*

（2）当p中获得最后一个结点的next值时*/

/*即最后一个结点信息已输出，p为空时结束输出*/

{printf（"

%ld,%f\n"

p->

num,p->

p=p->

next;

/*指针指向下一个结点*/

structSTU*delete（structSTU*head,longnum）/*删除结点*/

{structSTU*p,*q;

/*q总是指向p所指结点的前一个结点*/

if（head==NULL）{printf（"

\nListisnull!

while（num!

=p->

num&

&

next!

=NULL）

/*p所指向的结点不是所要找的结点，而且后面还有结点*/

{q=p;

p=p->

if（num==p->

num）/*找到了*/

{if（p==head）head=p->

/*若p指向的是首结点，把第二个结点地址赋予head*/

elseq->

next=p->

/*否则将下一个结点地址赋给前一个结点地址*/

Delete:

%ld\n"

num）;

elseprintf（"

numequal%ldnotbeenfound!

structSTU*insert（structSTU*head,structSTU*r）

/*插入结点*/

if（head==NULL）

{head=r;

r->

next=NULL;

{while（（r->

num>

num）&

（p->

=NULL））

/*查找待插位置*/

if（r->

num<

num）

{if（head==p）head=r;

/*插到原来第一个结点之前*/

next=r;

/*插到q指结点之后p指结点之前*/

r->

next=p;

else

{p->

}/*插到最后一个结点之后*/

n=n+1;

{structSTU*head,stu;

longdel_n;

head=sxcreate（）;

print（head）;

\nInputthedeletednumber:

"

%ld"

del_n）;

head=delete（head,del_n）;

\nInputtheinsertrecord:

stu.num,&

stu.score）;

head=insert（head,&

stu）;

structSTU*sxcreate（）/*顺序建表*/

{structSTU*head,*p,*q;

p=q=（structSTU*）malloc（sizeof（structSTU））;

/*注意，链表上的结点按学号升序排列*/

if（n==1）head=p;

q=p;

q->