C语言案例教程 - 第八章复合数据类型

09927306 · 发表于 2011-1-8 18:07:44

本帖最后由 09927306 于 2011-1-8 18:23 编辑

第8章：复合数据类型

【例8-1】

结构变量的初始化。

#include<stdio.h>
struct st
{ char str[5];
char *s;
int a;
struct
{ char c;
float w;
}d;
}；
main()
{ struct st x={"101","abcd",28, \'n\',45.8};
printf("%4s %-9s %3d %c %.2f\\n",x.str,x.s,x.a,x.d.c,x.d.w);
}

复制代码

程序运行结果如下：

101 abcd
28 n 45.80

【例8-2】

结构数组的初始化。

#include<stdio.h>
struct st
{ char str[5];
char *s;
int a;
struct
{ char c;
float w;
}d;
}
main()
{ struct st x[2]={{"101","abcd",28, \'n\',45.8},
{"1001","dog&god",14, \'y\',123}};
int i;
for(i=0;i<2;i++)
printf("%4s %-9s %3d %c %.2f\\n",
x[i].str,x[i].s,x[i].a,x[i].d.c,x[i].d.w);
}

复制代码

程序运行结果如下：

101 abcd
28 n 45.80

1001 dog&god
14 y 123.00

【例8-3】

假设学生的3门课成绩已保存在一个结构数组中，要求用子程序计算并返回3门课的总分。

先定义一个外部型的结构类型，在主程序main()中创建结构数组，并将该数组的成员score（数组）传递到子程序add()中，由add()计算总分并返回。

#include <stdio.h>
struct stu
{ char *name; int score[3]; int total;};
main()
{ struct stu student[30];
int i;
for (i=0;i<30;i++) /*创建结构数组*/
{ scanf("%s",student[i].name);
scanf("%d%d%d",&student[i].score[0],
&student[i].score[1],&student[i].score[2]);
student[i].total=add(student[i].score[0],
student[i].score[1],student[i].score[2]); /*调用add*/
}
for(i=0;i<30;i++)
printf("%-9s %d %d %d %d\\n",student[i].name,
student[i].score[0],student[i].score[1],
student[i].score[2],student[i].total);
}
add(int x,int y,int z) /*计算并返回总分*/
{ return x+y+z;}

复制代码

【例8-4】

定义一个结构变量，其成员包括两个整数a和b及一个字符串ch。主程序将该结构数据传递给子程序f1()，子程序计算a+b并保存在a中，同时将字符串ch中第3个字符替换为\'x\'，最后输出处理结果。

#include <stdio.h>
struct sample
{ int a,b; char *ch;};
void f1(struct sample parm)
{ parm.a+=parm.b;
parm.ch[2]=\'x\';
printf("%d,%s\\n",parm.a,parm.ch);
}
main(void)
{ struct sample arg;
arg.a=1000;arg.b=100;arg.ch="abcd";
f1(arg);
printf("%d,%s\\n",arg.a,arg.ch);
}

复制代码

【例8-5】

将例8-4改用结构指针来传递结构型数据。

#include <stdio.h>
struct sample
{ int a,b; char *ch;};
void f1(struct sample *p)
{ p->a+=p->b;
p->ch[2]=\'x\';
printf("%d,%s\\n",p->a,p->ch);
}
main()
{ struct sample arg;
arg.a=1000;arg.b=100;arg.ch="abcd";
f1(&arg);
printf("%d,%s\\n",arg.a,arg.ch);
}

复制代码

【例8-6】

建立一个小通讯录：input()用于输入通讯录数据，display()用于输出通讯录，主程序通过结构数组名调用input()和display()。

#include <stdio.h>
#define MAX 10
struct telephone
{ char name[20]; char mobile[12]; char phone[12];};
input(struct telephone *p)
{ int i;
for (i=0;i<MAX;i++)
{ printf("Name?");
gets(p->name);
if (p->name[0]==\'\\0\') return(i); /*提前结束输入*/
printf("Mobile?");
scanf("%*c%s",p->mobile);
printf("Telephone?");
scanf("%*c%s%*c",p->phone);
};
return MAX;
}
void display(struct telephone *p,int n)
{ int i;
for (i=0;i<n;i++,p++)
printf("%-20s %-12s %-12s\\n",p->name,p->mobile,p->phone);
}
main()
{ struct telephone tx[MAX];
int n;
n=input(tx);
display(tx,n); /*输出通讯录*/
}

复制代码

【例8-7】

一个汽车档案中包括汽车的编号、颜色和型号。输入一个汽车编号，由find()函数进行查找，根据查找结果输出查找到汽车的信息。

#include <stdio.h>
struct sample
{ int num; char color;
char type;} car[]={101,\'G\',\'c\',210,\'Y\',\'m\',105,\'R\',\'l\',
220,\'B\',\'s\',308,\'W\',\'b\',0,\'\\0\',\'\\0\'};
struct sample find(int n)
{ int i;
for (i=0;car[i].num!=0;i++)
if (car[i].num==n) break;
return(car[i]);
}
main()
{ int number;
struct sample result;
printf("Enter the number:");
scanf("%d",&number);
result=find(number);
if (result.num!=0)
{ printf("number:%d ",result.num);
printf("Color:%c ",result.color);
printf("type:%c\\n",result.type);
}
else
printf("Not found\\n");
}

复制代码

上一章：C语言案例教程 - 第七章程序的模块结构和C函数
下一章：C语言案例教程 - 第九章文件

09927306 · 发表于 2011-1-8 18:08:35

本帖最后由 09927306 于 2011-1-8 18:24 编辑

【例8-8】

例8-7的程序中的结构型函数也可以改用结构指针型函数。程序如下：

#include <stdio.h>
struct sample
{ int num; char color;
char type;} car[]={101,'G','c',210,'Y','m',105,'R','l',
220,'B','s',308,'W','b',0,'\0','\0'};
struct sample *find(int n)
{ int i;
for (i=0;car[i].num!=0;i++)
if (car[i].num==n) break;
return(&car[i]);
}
main()
{ int number;
struct sample *result;
printf("Enter the number:");
scanf("%d",&number);
result=find(number);
if (result->num!=0)
{ printf("number:%d ",result->num);
printf("Color:%c ",result->color);
printf("type:%c\n",result->type);
}
else
printf("Not found\n");
}

复制代码

【例8-9】

单向循环链表是链头和链尾相接的一种链表，如图8-5所示。编一个程序创建具有5个节点的单向循环链表，并计算该链表中每3个相邻节点数据域中数值的和，从中找出最小值。

图8-5
单向循环链表示意图

#include <stdlib.h>
struct node
{ int data;
struct node *next;};
main()
{ struct node *h,*p,*q;
int i,m,m3;
/* 建立5个节点的单向循环链表 */
p=q=h=(struct node *)malloc(sizeof(struct node));
for (i=0;i<5;i++)
{ printf("Input data:");
scanf("%d",&p->data); /* 建立当前节点数据域 */
p=(struct node *)malloc(sizeof(struct node));
if (i==4) continue;
q->next=p; /* 保存下一节点首地址 */
q=p;
}
/* 链头和链尾相接，形成单向循环链表 */
q->next=h;
/* p指向链头 */
p=h;
/* 计算每3个相邻节点数据值之和，寻找最小值，直至回到链头 */
m3=p->data+p->next->data+p->next->next->data;
printf("%d\t",m3); /*输出前3个节点数据之和*/
for (p=p->next;p!=h;p=p->next)
{ m=p->data+p->next->data+p->next->next->data;
printf("%d\t",m); /*输出相邻3个节点数据之和*/
if (m3>m) m3=m;
}
printf("MIN=%d\n",m3); /*输出最小值*/
}

复制代码

【例8-10】

利用联合自动选择输入输出格式控制的程序。

我们可以定义一个结构sdata，它的一个成员是联合udata，用来存放各种类型的变量样本；另一个成员是整型变量type，用来存放值的类型(如int型为1，long int型为2，float型为3等)，程序接收到用户输入类型代码后，可以自动确定用哪一种格式转换说明符来正确输入和输出数据。

#include <stdio.h>
#define INT 1
#define LONG 2
#define FLOAT 3
#define DOUBLE 4
#define CHAR 5
#define STRING 6
union uda
{ int uin; long ulo; float ufl;
double udo; char uch; char *ust;}udata;
struct sda
{ union uda udata; int type;};
void in_out();
main()
{ struct sda sdata,*p=&sdata;
printf("Input type:");
scanf("%d%*c",&p->type);
in_out(p);
}
void in_out(struct sda *b)
{ printf("Input value:");
switch(b->type)
{ case INT:
scanf("%d",&b->udata.uin);
printf("%d\n",b->udata.uin); break;
case LONG:
scanf("%ld",&b->udata.ulo);
printf("%ld\n",b->udata.ulo); break;
case FLOAT:
scanf("%f",&b->udata.ufl);
printf("%f\n",b->udata.ufl); break;
case DOUBLE:
scanf("%f",&b->udata.udo);
printf("%lf\n",b->udata.udo); break;
case CHAR:
scanf("%c",&b->udata.uch);
printf("%c\n",b->udata.uch); break;
case STRING:
printf("%s",b->udata.ust);
printf("%s\n",b->udata.ust); break;
default:
printf("Type error");
}
}

复制代码

【例8-11】

利用联合成员共享存储单元的特点，将int型数据的高字节和低字节分离出来。

在IBM PC系列计算机中，int型数据的存储格式是低字节在前，高字节在后。例如，整数6699的十六进制表示为0x1a2b，其存储格式为：

2b

1a

因此，可以用字符型数组ch[2]与int型变量a共享存储单元。这样，c[0]和c[1]分别与a的高字节和低字节共享存储单元，通过ch[0]和ch[1]即可分离出a的2个字节。程序如下：

union un
{ int a;
char ch[2]; }data;
main()
{ scanf("%x",&data.a);
printf("%x %x\n",data.ch[0],data.ch[1]);
}

复制代码

程序运行时，若输入为：1a2b，则输出为：2b
1a。

【例8-12】

位段成员的初始化、赋值和输出。

main()
{ struct bit
{ unsigned a:1;
unsigned b:2;
unsigned c:3;
int d; } s={1,2,3,4};
s.c=7;s.d=125;
printf("%d %d %d %d\n",s.a,s.b,s.c,s.d);
}

复制代码

程序运行结果如下：

1
2
5
125

【例8-13】

位段的输入和输出。

由于位段没有自己的地址，不能直接用scanf()来输入。解决这一问题的一种方法是先将数据输入到一个无符号整型变量中，再通过强制类型转换把该变量的地址赋给位段结构变量的指针，使输入的整数被自动赋给位段结构的各个成员。

struct bit
{ unsigned bund_bit:2;
unsigned char_bit:2;
unsigned pari_bit:1;
unsigned even_bit:2;
unsigned stop_bit:2;
unsigned dummy_bit:8; };
main()
{ struct bit *p;
unsigned int word;
printf("Input the value of word(HEX): ");
scanf("%x",&word);
p=(struct bit *)&word;
printf("%d %d %d %d %d\n",p->bund_bit,p->char_bit,
p->pari_bit,p->even_bit,p->stop_bit);
}

复制代码

程序在IBM PC系列计算机上的运行结果如下：

Input the value of word (HEX):b6↙

2
1
1
1
1

【例8-14】

也可以利用联合成员共享存储单元的特点，将一个整型值装入位段。

struct bit
{ unsigned bund_bit:2;
unsigned char_bit:2;
unsigned pari_bit:1;
unsigned even_bit:2;
unsigned stop_bit:2;
unsigned dummy_bit:8; };
main()
{ union
{ struct bit eq; unsigned i; } abc;
abc.i=182;
printf("%d %d %d %d %d\n",abc.eq.bund_bit,abc.eq.char_bit,
abc.eq.pari_bit,abc.eq.even_bit,abc.eq.stop_bit);
}

复制代码

【例8-15】

枚举变量用做循环变量和数组下标。

enum coin {penny,nickel,dime,quarter,half_dollar,dollar};
char name[][10]={"January","February","March","April","May","June",
"July","August","September","October","November","December"};
main()
{ enum coin money;
for(money=penny;money<=dollar;money++)
printf("%s ",name[money]);
}

复制代码

程序运行结果如下：

January
February
March
April
May
June

C语言案例教程 - 第八章 复合数据类型

C语言案例教程 - 第八章复合数据类型