几种结构体定义的区别
2011-09-17 16:50:30| 分类：H264|举报|字号订阅以下几种结构体定义的区别：
struct {
int x;
int y;
} test1;
struct test
{
int x;
int y;
}test1;
typedef struct test
{
int x;
int y;
} text1,text2;
typedef struct
{
int x;
int y;
} test1;
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
(1)
struct{
int x;
int y;
}test1; 定义了结构体的对象test1， test1.x 和 test1.y 可以在语句里用了。 (2)
struct test {
int x;
int y;
}test1; 好，定义了结构test，同时定义了结构体的对象 test1， test1.x 和 test1.y 可以在语句里用了。与 (1) 比，省写了 test (3) typedef struct test {int x; int y; // 你漏打分号，给你添
上 }text1,text2; 只说了这种结构的（类型）别名叫 text1 或叫
text2 真正在语句里用，还要写： text1 test1; 然后好用 test1.x
test1.y 或写 text2 test1; 然后好用 test1.x test1.y （4）type struct {int x; int y; }test1; 这个不可以。改 typedef ... 就可以了。但也同（3）一样，还要写： test1 my_st; 才能用 my_st.x 和 my_st.y
typedef的用法及与define的区别总结
2011-01-19 12:03:25| 分类：VC++|举报|字号订阅
一、typedef的用法
在C/C++语言中，typedef常用来定义一个标识符及关键字的别名，它是语言编译过程的一部分，但它并不实际分配内存空间，实例像：
typedef int INT;
typedef int ARRAY[10];
typedef (int*) pINT;
typedef可以增强程序的可读性，以及标识符的灵活性，但它也有“非直观性”等缺点。
typedef 还可以掩饰符合类型，如指针和数组。例如，你不用象下面这样重复定义有81 个字符元素的数组：
char line[81]; char text[81];
定义一个typedef，每当要用到相同类型和大小的数组时，可以这样：
typedef char Line[81]; Line text, secondline; getline(text);
同样，可以象下面这样隐藏指针语法：
typedef char * pstr; int mystrcmp(pstr, pstr);
这里将带我们到达第一个typedef 陷阱。标准函数strcmp()有两个…const char *?类型的参数。因此，它可能会误导人们象下面这样声明mystrcmp()：int mystrcmp(const pstr, const pstr);
这是错误的，按照顺序，…const pstr?被解释为…char * const?（一个指向char 的常量指针），而不是…const char *?（指向常量char 的指针）。这个问
题很容易解决：
typedef const char * cpstr; int mystrcmp(cpstr, cpstr); // 现在是正确的
记住：不管什么时候，只要为指针声明typedef，那么都要在最终的typedef 名称中加一个const，以使得该指针本身是常量，而不是对象。
代码简化
上面讨论的typedef 行为有点像#define 宏，用其实际类型替代同义字。不同点是typedef 在编译时被解释，因此让编译器来应付超越预处理器能力的
文本替换。例如：
typedef int (*PF) (const char *, const char *);
这个声明引入了PF 类型作为函数指针的同义字，该函数有两个
const char * 类型的参数以及一个int 类型的返回值。如果要使用下列形式的函数声明，那么上述这个typedef 是不可或缺的：
PF Register(PF pf);
Register() 的参数是一个PF 类型的回调函数，返回某个函数的地址，其署名与先前注册的名字相同。做一次深呼吸。下面我展示一下如果不用typedef，我们是如何实现这个声明的：
int (*Register (int (*pf)(const char *, const char *))) (const char *, const char *);
很少有程序员理解它是什么意思，更不用说这种费解的代码所带来的出错风险了。显然，这里使用typedef 不是一种特权，而是一种必需。持怀疑态度的人可能会问：“OK，有人还会写这样的代码吗？”，快速浏览一下揭示signal()函数的头文件
typedef 和存储类关键字（storage class specifier）
这种说法是不是有点令人惊讶，typedef 就像auto，extern，mutable，static，和register 一样，是一个存储类关键字。这并是说typedef 会真正影响对象的存储特性；它只是说在语句构成上，typedef 声明看起来象static，extern 等类型的变量声明。下面将带到第二个陷阱：
typedef register int FAST_COUNTER; // 错误
编译通不过。问题出在你不能在声明中有多个存储类关键字。因为符号typedef 已经占据了存储类关键字的位置，在typedef 声明中不能用register （或任何其它存储类关键字）。
促进跨平台开发
typedef 有另外一个重要的用途，那就是定义机器无关的类型，例如，你可以定义一个叫REAL 的浮点类型，在目标机器上它可以i获得最高的精度：typedef long double REAL;
在不支持long double 的机器上，该typedef 看起来会是下面这样：typedef double REAL;
并且，在连double 都不支持的机器上，该typedef 看起来会是这样：、typedef float REAL;
你不用对源代码做任何修改，便可以在每一种平台上编译这个使用REAL 类型的应用程序。唯一要改的是typedef 本身。在大多数情况下，甚至这个微小的变动完全都可以通过奇妙的条件编译来自动实现。不是吗? 标准库广泛地使用typedef 来创建这样的平台无关类型：size_t，ptrdiff 和fpos_t 就是
其中的例子。此外，象std::string 和std::ofstream 这样的typedef 还隐藏了长长的，难以理解的模板特化语法，例如：basic_string
二、#define的用法
#define为一宏定义语句，通常用它来定义常量(包括无参量与带参量)，以及用来实现那些“表面似和善、背后一长串”的宏，它本身并不在编
译过程中进行，而是在这之前(预处理过程)就已经完成了，但也因此难以发现潜在的错误及其它代码维护问题，它的实例像：
#define INT int
#define TRUE 1
#define Add(a,b) ((a)+(b));
#define Loop_10 for (int i=0; i<10; i++)
三、typedef与#define的区别
从以上的概念便也能基本清楚，typedef只是为了增加可读性而为标识符另起的新名称(仅仅只是个别名)，而#define原本在C中是为了定义常量，到了C++，const、enum、inline的出现使它也渐渐成为了起别名的工具。有时很容易搞不清楚与typedef两者到底该用哪个好，如#define INT int这样的语句，用typedef一样可以完成，用哪个好呢？我主张用typedef，因为在早期的许多C编译器中这条语句是非法的，只是现今的编译器又做了扩充。为了尽可能地兼容，一般都遵循#define定义“可读”的常量以及一些宏语句的任务，而typedef则常用来定义关键字、冗长的类型的别名。
宏定义只是简单的字符串代换(原地扩展)，而typedef则不是原地扩展，它的新名字具有一定的封装性，以致于新命名的标识符具有更易定义变量的功能。请看上面第一大点代码的第三行：
typedef (int*) pINT;
以及下面这行:
#define pINT2 int*
效果相同？实则不同！实践中见差别：pINT a,b;的效果同int *a; int *b;表示定义了两个整型指针变量。而pINT2 a,b;的效果同int *a, b;
表示定义了一个整型指针变量a和整型变量b。
注意：两者还有一个行尾;号的区别哦！
结构体、共用体和枚举类型数据
2010-07-31 18:57:08| 分类：VC++|举报|字号订阅
一、要点提示
13.1.1结构体的概念
13.1.2 结构体数组
13.1.3结构体指针
二、内容简介
14.1.1结构体的概念
结构体的定义
结构体变量的存储特点
结构体变量的引用
结构体的初始化
结构体的定义
1、含义：不同类型数据的集合。
2、功能：用于描述一个“概念”。（或记录）
如：num name sex age score addr
10010 LiFun M 18 87.5 BeiJing
3、定义方法：
方法一：在定义结构体类型的同时，直接给出结构体变量。
如： struct 结构体名
{ 结构体成员变量的定义；
} 变量名1，变量名2，...，变量名n ；
方法二：先给出结构体类型的定义，再定义结构体变量。
如： struct 结构体名
{ 结构体成员变量的定义； 例：
} ；
struct 结构体名 变量名1，变量名2，...，变量名n ；
方法一：
struct student
{ int number;
char name[20];
char sex;
int age;
float score;
char addr[30]; }student1,student2; 方法二： struct student { int number; char name[20]; char sex; int age; float score; char addr[30]; }; struct studentstudent1,student2;
请注意两种方法的不同特点：
（1）“；”的用法；
（2）方法二可以用一个*.h 文件来存储结构体的定义。
4、要点：
结构体名（struct)：
用于标识一种新的数据类型，即结构体类型。
注意区分结构体类型与基本数据类型的不同，它是复合数据类型。
结构体成员变量与普通变量的定义一样，它还可以是结构体变量。
struct date
{int month,day,year;};
struct student
{ int num;
char name[20];
char sex;
int age;
struct date birthday;
char addr[30];
}student1,student2;
结构体变量的存储特点
如：
struct student
{ int number;
char name[5];
char sex;
int age;
float score;
char addr[10];
}student1,student2;
struct student所占存
储空间的大小为：
各成员变量所占存储
单元字节数之和。
结构体类型变量的引用
一、原则：通过结构体的成员来引用结构体变量。
二、成员的引用方法为:结构体变量名.成员名
三、要点：
1.结构体变量不能整体输入输出,只能对它的成员进行操作.
如:student1.num;
2.如果成员本身又是一个结构体类型,则要使用若干个成员运算符,逐级找到最底层的成员.
如:student1.birthday.day
3.成员变量可以象一般的变量一样进行各种运算,只是在运算时要加上“.”运算符.
4.可以引用成员的地址.
结构体变量的初始化
一、只可以给主函数中或外部存储类别和静态存储类别的结构体变量、数组赋初值。
1、对外部存储类型的初始化.
2、对静态存储类型的结构体变量进行初始化
二、给结构体变量赋初值不能跨越前面的成员而只给后面的成员变量赋值。
例exp8_1:对外部存储类型的初始化.
struct student
{ long number;
char name[20];
char sex; int age;
float score;
char addr[30];
}a={99641,”Li Ping”,?M?,”56 Tianjin Street”};
main()
{ printf(“No.:%ld\nname:%s\nsex:%c\naddress:%s\n”,
a.num,https://www.doczj.com/doc/cc5946170.html,,a.sex,a.addr);
}
例exp8_2:对静态存储类型的结构体变量进行初始化.
main() { static struct student
{ long number;
char name[20];
char sex;
int age;
float score;
char addr[30];
}a={99641,”Li Ping”,?M?,”56 Tianjin Street”};
printf(“No.:%ld\nname:%s\nsex:%c\naddress:%s\n”,a.num,https://www.doczj.com/doc/cc5946170.html,,a.sex,a.ad dr);
}
13.1.2 结构体数组
结构体数组的含义：
数组元素是结构体类型数据的数组称为结构体数组.
※结构体数组的定义
※结构体数组的初始化
※结构体数组的应用举例
※结构体数组的定义
一、含义：若干个相同的结构体类型变量组成的数据集合。
二、定义方法：
struct 结构体名
{ 例如：
结构体成员定义；
}数组名[元素个数]；
三、结构体数组的使用方法
1、通过数组的下标（或指向数组的指针）来访问结构体变量。
2、再通过结构体变量的成员实现结构体数据的访问。
形式为：数组名[下标].成员名
如：stu[2].name=“Wang Ying”;
struct student { long number; char name[20]; char sex;
int age;
float score; char addr[30]; }stu[3]; struct student
{ long number;
char name[20];
char sex;
int age;
float score;
char addr[30];};
struct student stu[3];
结构体数组的物理含义：
表示实体（或记录）的个数。※结构体数组的初始化
1、含义：在定义结构体数组时完成数组元素的赋值
2、方法：与一般数组元素赋初值的方法相同。
struct student
{ long number;
char name[20];
char sex;
int age;
float score;
char addr[30];
}a[3]={{99641,”Li Ping”,?M?,”56 Tianjin Street”},
{99341,”Zhang Fan”,”F”,78 Beijing Road”},
{99441,”Ren Zhong”,”M”,34 Shenyang Road”}};
※结构体数组的应用举例
例exp8_3: 对候选人得票的统计程序,设有三个候选人,每次输入一个候选人的名字,最后统计出每个候选人的得票的结果.
struct person
{ char name[20];int count;
}leader[3]={“Li”,0,”Zhang”,0,”Fun”,0};
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”,leade r[i].name,lader[i].count);}
13.1.3结构体指针
※指向结构体变量的指针
※指向结构体数组的指针
※指向结构体的指针作函数的参数
※利用结构体变量构成链表
※指向结构体变量的指针
一、含义：
1、结构体变量的指针：
指结构体变量所占内存单元的起始地址
2、指向结构体变量的指针
指向结构体变量的起始地址的指针变量.
二、定义方法与使用
1、结构体指针的定义：
main() { struct student
{ long number;
char name[20];
char sex;
int age;
float score;
char addr[30];
}a={99641,”Li Ping”,?M?,”56 Tianjin Street”},*p=&a;
2、结构体指针的使用：
a.num,https://www.doczj.com/doc/cc5946170.html,,a.sex,a.addr
(*p).num,(*p).name,(*p).sex,(*p).addr;
p->num,p->name,p->sex,p->addr;
三、要点:
1、必须将指针指向一个确定的结构体变量，如：p=&a;
2、通过结构体变量的指针访问结构体的方法为:
a.num、(*p).num、p->num。
3、区分下面的两种用法：
p->n++ 和++p->n
※指向结构体数组的指针
1、定义方法举例：
例exp8_4：指向结构体数组的指针
struct student
{ long number;char name[20];
char sex;int age;
float score; char addr[30];
}a[3]={{99641,”Li Ping”,?M?,”56 Tianjin Street”},
{99341,”Zhang Fan”,”F”,78 Beijing Road”},
{99441,”Ren Zhong”,”M”,34 Shenyang Road”}};
main() { struct student *p;
for(p=a;p printf(“%ld，%-20s，%2c，%4d，%5.2f，%-20s\n”， p->num,p->name,p->sex,p->age,p->score,p->addr); } 2、使用要点： 1.p++:是指针p指向数组的下个元素,而这个元素是由结构体类型数据组成的,它不是一个简单的变量. 2.(++p)->num:先使指针p指向结构体数组当前位置的下一个元素,再访问其元素成员num; 请区别与(p++)->num的不同。 ※指向结构体的指针作函数的参数 1、用结构体变量的成员作函数的参数与一般变量作函数的参数一致; 2、用指向结构体变量的指针作函数的参数,实参将地址传递给形参,与前面指针作函数参数一致; 3、新版本的c语言允许将整个结构体变量作为函数的参数进行传递,要求形参与实参的类型必须一致,而且程序占用内存大,运行速度慢. ※利用结构体变量构成链表一、链表的含义： 当一个结构体中有一个成员是指向本结构体的指针时，通过这样的指针可以将若干个相同的结构体存储单元连接成一个新的数据结构。举例： 二、功能：可以根据需要动态的开辟存储空间。 1.malloc(size):在内存中动态的分配一个长度为size的连续空间; 2.calloc(n,size):在内存中分配n个长度为size的连续空间; 3.free(ptr):释放由ptr指针指向的内存区域. 二、链表操作 建立链表、在链表插入结点、删除链表结点 单链表的结构： struct student { int num; float score; struct student *next; }; 要点： 1、链表中的元素在内存中存放顺序是不连续的。 由next指针来连接各节点。 2、链表数据结构的实现,必须利用指针变量. 建立含n个节点的链表过程: struct student *creat( ) {struct student *head,*p1,*p2; n=0;head=NULL; p1=p2=(struct student *)(malloc(sizeof(struct student))); scanf(“%ld,%f”,&p1->num,&p1->score); while(p1->num!=0) { n=n+1;if(n==1) head=p1; else p2->next=p1; p2=p1;p1=(struct student *)(malloc(sizeof(struct student))); s canf(“%ld,%f”,&p1->num,&p1->score);} p2->next=NULL;return(head);} 在链表中插入结点的过程 在C++中结构体和类可以通用 什么是结构体？ 简单的来说，结构体就是一个可以包含不同数据类型的一个结构，它是一种可以自己定义的数据类型，它的特点和数组主要有两点不同，首先结构体可以在一个结构中声明不同的数据类型，第二相同结构的结构体变量是可以相互赋值的，而数组是做不到的，因为数组是单一数据类型的数据集合，它本身不是数据类型(而结构体是)，数组名称是常量指针，所以不可以做为左值进行运算，所以数组之间就不能通过数组名称相互复制了，即使数据类型和数组大小完全相同。 定义结构体使用struct修饰符，例如： struct test { float a; int b; }; 上面的代码就定义了一个名为test的结构体，它的数据类型就是test，它包含两个成员a和b，成员a的数据类型为浮点型，成员b的数据类型为整型。 由于结构体本身就是自定义的数据类型，定义结构体变量的方法和定义普通变量的方法一样。 test pn1; 这样就定义了一test结构体数据类型的结构体变量pn1，结构体成员的访问通过点操作符进行， pn1.a=10 就对结构体变量pn1的成员a进行了赋值操作， 注意:结构体生命的时候本身不占用任何内存空间，只有当你用你定义的结 构体类型定义结构体变量的时候计算机才会分配内存。 结构体，同样是可以定义指针的，那么结构体指针就叫做结构指针。 结构指针通过->符号来访问成员，下面我们就以上所说的看一个完整的例子：//程序作者:管宁 //站点:https://www.doczj.com/doc/cc5946170.html, //所有稿件均有版权,如要转载,请务必著名出处和作者 #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< cout< test *point;//定义结构指针 point=&pn2;//指针指向结构体变量pn2的内存地址 cout< point->a=99;//通过结构指针修改结构体变量pn2成员a的值 cout< cout< cin.get(); } 总之，结构体可以描述数组不能够清晰描述的结构，它具有数组所不具备的一些功能特性。 下面我们来看一下，结构体变量是如何作为函数参数进行传递的。 //程序作者:管宁 //站点:https://www.doczj.com/doc/cc5946170.html, //所有稿件均有版权,如要转载,请务必著名出处和作者 #include #include using namespace std; struct test { char name[10]; float socre; }; void print_score(test pn)//以结构变量进行传递 { cout< } void print_score(test *pn)//一结构指针作为形参 { cout< } void main() { test a[2]={{"marry",88.5},{"jarck",98.5}}; int num = sizeof(a)/sizeof(test); for(int i=0;i { print_score(a[i]); } for(int i=0;i { print_score(&a[i]); } cin.get(); } void print_score(test *pn)的效率是要高过void print_score(test pn)的，因为直接内存操作避免了栈空间开辟结构变量空间需求，节省内存。 下面我们再说一下，传递结构引用的例子。 利用引用传递的好处很多，它的效率和指针相差无几，但引用的操作方式和值传递几乎一样，种种优势都说明善用引用可以做到程序的易读和易操作，它的优势尤其在结构和大的时候，避免传递结构变量很大的值，节省内存，提高效率。 //程序作者:管宁 //站点:https://www.doczj.com/doc/cc5946170.html, //所有稿件均有版权,如要转载,请务必著名出处和作者#include #include using namespace std; struct test { char name[10]; float socre; }; void print_score(test &pn)//以结构变量进行传递{ cout< } void main() { test a[2]={{"marry",88.5},{"jarck",98.5}}; int num = sizeof(a)/sizeof(test); for(int i=0;i { print_score(a[i]); } cin.get(); } //程序作者:管宁 //站点:https://www.doczj.com/doc/cc5946170.html, //所有稿件均有版权,如要转载,请务必著名出处和作者 //-------------------------------------例程1--------------------------------- #include #include using namespace std; struct test { char name[10]; float socre; }; void print_score(test &pn) { cout< } test get_score() { test pn; cin>>https://www.doczj.com/doc/cc5946170.html,>>pn.socre; return pn; } void main() { C++语言结构体和指针 指针也可以指向一个结构体，定义的形式一般为： struct结构体名*变量名; 下面是一个定义结构体指针的实例： 上述代码已经测试。 注意：定义已经命名的结构体指针的时候必须用已命名结构体类型定义的结构体变量的地址进行初始化。 也可以在定义结构体的同时定义结构体指针： 上述代码已经测试 注意，结构体变量名和数组名不同，数组名在表达式中会被转换为数组指针，而结构体变量名不会，无论在任何表达式中它表示的都是整个集合本身，要想取得结构体变量的地址，必 pstu赋值只能写作： struct stu *pstu = &stu1; 而不能写作： struct stu *pstu = stu1; 还应该注意，结构体和结构体变量是两个不同的概念：结构体是一种数据类型，是一种创建变量的模板，编译器不会为它分配内存空间，就像int、float、char 这些关键字本身不占用内存一样；结构体变量才包含实实在在的数据，才需要内存来存储。下面的写法是错误的，不可能去取一个结构体名的地址，也不能将它赋值给其他变量： struct stu *pstu = &stu; struct stu *pstu = stu; 获取结构体成员 通过结构体指针可以获取结构体成员，一般形式为： (*pointer).memberName 或者： pointer->memberName 对了。 ，有了它，可以通过结构体指针 直接取得结构体成员；这C语言中的唯一用途。 上面的两种写法是等效的，我们通常采用后面的写法，这样更加直观。 运行结果： Name Num Age Group Score Zhou ping 5 18 C 145.0 Zhang ping 4 19 A 130.5 Liu fang 1 18 A 148.5 Cheng ling 2 17 F 139.0 Wang ming 3 17 B 144.5 结构体指针作为函数参数 结构体变量名代表的是整个集合本身，作为函数参数时传递的整个集合，也就是所有成员，而不是像数组一样被编译器转换成一个指针。如果结构体成员较多，尤其是成员为数组时，传送的时间和空间开销会很大，影响程序的运行效率。所以最好的办法就是使用结构体指针，这时由实参传向形参的只是一个地址，非常快速。 要铭记的一点就是：数组名称始终代表数组的指针指向第一个元素，数组名称加一始终指向下一个数组元素。 C语言程序设计(第7章结构体与共用体)3 7.3 结构体指针的定义和引用 指针变量非常灵活方便，可以指向任一类型的变量，若定义指针变量指向结构体类型变量，则可以通过指针来引用结构体类型变量。 7.3.1 指向结构体类型变量的使用 首先让我们定义结构体： struct stu { char name[20]; long number; float score[4]; } ; 再定义指向结构体类型变量的指针变量： struct stu *p1, *p2 ; 定义指针变量p 1、p 2，分别指向结构体类型变量。引用形式为：指针变量→成员； [例7-2] 对指向结构体类型变量的正确使用。输入一个结构体类型变量的成员，并输出。 #include /*使用malloc( ) 需要*/ struct data /*定义结构体*/ { int day,month,year; }; struct stu /*定义结构体*/ { char name[20]; long num; struct data birthday; /* 嵌套的结构体类型成员*/ } ; main() /*定义main( ) 函数*/ { struct stu *student; /* 定义结构体类型指针*/ student=malloc(sizeof(struct stu)); /* 为指针变量分配安全的地址* / printf("Input name,number,year,month,day:\n"); scanf("%s",student->name); /* 输入学生姓名、学号、出生年月日*/ scanf("%ld", &student->num); scanf("%d %d %d", &student->birthday.year,&student->birthday.month,&student->birthday.day); printf("\nOutput name,number,year,month,day\n" ); /*打印输出各成员项的值*/ printf("%20s%10ld%10d//%d//%d\n",student->name,student->num,student->birthda y.year,student->birthday.month,student->birthday.day); } 程序中使用结构体类型指针引用结构体变量的成员，需要通过C提供的函数malloc( )来为指针分配安全的地址。函数sizeof( )返回值是计算给定数据类型所占内存的字节数。指针所指各成员形式为： student->name student->num student->birthday.year student->birthday.month student->birthday.day 运行程序： Input name,number,year,month,day: Wangjian 34 1987 5 23 Wangjian 34 1987//5//23 7.3.2 指向结构体类型数组的指针的使用 定义一个结构体类型数组，其数组名是数组的首地址，这一点前面的课程介绍得很清楚。定义结构体类型的指针，既可以指向数组的元素，也可以指向数组，在使用时要加以区分。 [例7-3] 在例7 - 2中定义了结构体类型，根据此类型再定义结构体数组及指向结构体 (1)（）是关于C语言数据类型的正确叙述。 A) 枚举类型不是基本类型 B) 变量使用前应定义相应的数据类型 C) 不允许使用空类型 D) 数组不是构造类型 (2) 下列（）对结构类型变量定义是错误的。 A) struct teacher { int num; int age; }; struct teacher teach1; B) struct { int num; int age; } teach1, teach2; C) struct { int num; int age; } teacher; struct teacher teach1; D) struct teacher { int num; int age; } teach1; (3) 若有定义： char ch; int j,k; enum day {sun, mon, tue, wed, thu, fri, sat}; int a[sat]; 则（）对下列语句是否符合语法规则的判断是正确的。 sun=0; /*语句1*/ j=mon+tue; /*语句2*/ if (a[mon]>0) j++; /*语句3*/ A) 语句1、2、3均正确 B) 语句2正确，语句1和语句3错误 C) 语句1错误，语句2和语句3正确 D) 语句1、2、3均错误 (4) 若有定义： struct teacher { int num; char sex; int age; } teacher1; 则下面叙述错误的是（）。 A) teacher1是结构类型名 B) struct teacher是用户定义的结构类型 C) num、sex、age都是结构变量teacher1的成员 D) struct是结构类型的关键字 (5) 下列程序段运行后，表达式（）的值为3。 struct point { int x; int y; } *p; struct point a[3]={1,2,3,4,5,6}; p=a; A) p[1].x B) *(p+2) C) p[3].x D) p[2].x (6) 若有定义： typedef int NUM[100]; NUM n; 则（）语句是正确的。 A) n[0]=2; B) NUM=2; C) NUM=n; D) n=2; (7) 若有定义int a=1,b=2,t=3; struct data { char a; float b[3]; long c; }d1; 则变量d1的长度是（）。 A) 4 B) 17 C) 12 D) 15 (8) 若有定义 struct teacher { int num; 第七章结构体 一、选择题 1、设有以下说明语句： srruct ex { int x ; int y ; int z ; }example ; 由以下叙述中不正确的是。 A．struct是结构体类型的关键字B．example是结构体类型名 C．x, y, z都是结构体成员名D．struct ex 是结构体类型 2、若有以下结构体定义，则是正确的引用或定义。 struct example { int x ; int y ; } v2 ; A．example.x=10 ;B．example v2.x =10; C．struct v2; v2.x = 10; D．struct example v2 = { 10 }; 3、已知：struct { int i ; char c ; float a ; } ex; 则sizeof( ex )的值是。 A．4 B．5 C．6 D．7 4、以下程序的运行结果是。 main () { struct sample { int x ; int y ; }a[ 2 ] = { 1, 2, 3, 4 }; printf ( "%d\n", a[0].x +a[0].y * a[1].y ); } A．7 B．9 C．13 D．16 5、若有如下定义，则对data中a成员的正确引用是。 struct sk { int a ; float b ; } data, *p = &data ; A．(*p).data.a B．(*p).a C．p->data.a D．p.data.a 二、编程题 1、利用两个结构体变量求解复数的积：（5 + 3i）*（2 + 6i） 什么是结构体？ 简单的来说，结构体就是一个可以包含不同数据类型的一个结构，它是一种可以自己定义的数据类型，它的特点和数组主要有两点不同，首先结构体可以在一个结构中声明不同的数据类型，第二相同结构的结构体变量是可以相互赋值的，而数组是做不到的，因为数组是单一数据类型的数据集合，它本身不是数据类型(而结构体是)，数组名称是常量指针，所以不可以作为左值进行运算，所以数组之间就不能通过数组名称相互复制了，即使数据类型和数组大小完全相同。 定义结构体使用struct修饰符，例如： struct test { float a; int b; }; 上面的代码就定义了一个名为test的结构体，它的数据类型就是test，它包含两个成员a和b，成员a的数据类型为浮点型，成员b的数据类型为整型。由于结构体本身就是自定义的数据类型，定义结构体变量的方法和定义普通变量的方法一样。 test pn1; 这样就定义了一个test结构体数据类型的结构体变量pn1，结构体成员的访问通过点操作符进行，pn1.a=10 就对结构体变量pn1的成员a进行了赋值操作。注意:结构体生命的时候本身不占用任何内存空间，只有当你用你定义的结构体类型定义结构体变量的时候计算机才会分配内存。 结构体，同样是可以定义指针的，那么结构体指针就叫做结构指针。 结构指针通过->符号来访问成员，下面我们就以上所说的看一个完整的例子： #include 第十章指针 一?选择题 1.变量的指针，其含义是指该变量的 _______________ A )值 B )地址 C )名 D )一个标志 2.已有定义int k=2;int *ptr1,*ptr2; 且ptr1和ptr2 均已指向变量 k ,下面不能正确执行 的赋值语句是 。 A ) k=*ptr1+*ptr2 B ) ptr2=k C ) ptr1=ptr2 D ) k=*ptr1*(*ptr2) 3.若有说明：int *p,m=5,n; 以下程序段正确的是 。 A ) p=&n ; B ) p = &n ; scanf( %d "，&p); scanf( %d ",*p); C ) scanf( %d",&n); D ) p = &n ; *p=n ; *p = m ; 4.已有变量定义和函数调用语句： int a=25;print_value(&a); 下面函数的输出结果 void prin t_value(i nt *x) { printf( %d\n ”++*x); } A) 23 B )24 C ) 25 D )26 5. 若有说明：int *p1, *p2,m=5,n; _____________ 以下均是正确赋值语句的选项是 B) p 仁&m; p2=&n; *p1 =* p2 ; C) p 仁&m; p2=p1 ; D ) p 仁&m; *p 仁*p2 ; 6. 若有语句：int *p,a=4; 和p=&a ;下面均代表地址的一组选项是 _ A) a,p,*&a B )&*a,&a,*p C )*&p,*p,&a D ) &a,&*p,p 7. 下面判断正确的是 ______________ 。 A) char *a= "ch in a ” 等价于 char *a; *a= "ch in a "; B) char str[1O]={ “hina ”；等价于 char str[1O]; str[ ]={ “hina";} C) char *s= "ch in a "; 等价于 char *s; s= "ch in a "; D) char c[4]= "abc ",d[4]= "abc ";等价于 char c[4]=d[4]= "abc "; 8. _______________________________________________ 下面程序段中，for 循环的执行次数是 ______________________________________________________ 。 char *s= "\ta\018bc "; for ( ; *s!= '\0'; s++) printf( *” A) 9 B ) 7 9. 下面能正确进行字符串赋值操作的是 A) char s[5]={ ABCDE ”; C ) char *s ; s= "ABCDE "; 10. 下面程序段的运行结果是 ________ char *s= "abcde"; s+=2 ; printf( %d",s); A) cde B )字符'' C )字符’c'的地址 D )不确定 11. 设pl 和p2是指向同一个字符串的指针变量， c 为字符变量，则以下不能正确执行的赋 值语句是 ________________ 。 A) c=*p1+*p2 B ) p2=c C ) p 仁p2 D ) c=*p1*(*p2) A ) p 仁&m; p2=&p1 ; C ) 6 D ) 5 B ) char s[5]={ A \'\'C','D','E '; D ) char *s; scanf( %s",s); 第1章 一、简答题 1．关于Linux的版本有两种不同的称呼： 一种是内核版本，一种是发行版本。 2.简述Linux操作系统的特点 3．系统调用、库函数的区别和练习 从用户角度观察，系统调用和库函数都以C函数形式出现，提供给用户一种功能实现的接口，需要用户输入指定的参数，调用结束得到指定的返回值。 从实现者角度观察，库函数是在系统调用上层的函数，库函数一般指程序员可以使用的通用函数。 系统调用由两部分组成： （1）核心函数：是实现系统调用功能的代码，作为操作系统的核心驻留在内存中，是一种共享代码。运行在核心态。 （2）接口函数：是提供给应用程序的API，以库函数的形式存在于Linux的lib.a中，该库中存放了所有系统调用的接口函数的目标代码，用汇编语言书写。其主要功能是把系统调用号，入口参数地址传给相应的核心函数，并使用户态下运行的应用程序陷入核心态。 4．完成如下命令 （1）新建用户tom 和用户组student #useradd tom #passwd tom #groupadd student （2）新建文件file #touch file （3）将文件file 改名为test，然后将test拷贝到/home #mv file test #cp test /home （4）将/home/test文件的拥有着修改为tom，将文件所属组该为student #chown tom:student /home/test 第2章 一、填空题 1．Vi的三中工作模式：插入模式、命令模式、末行模式。 2．Gcc生成可执行文件的四个步骤：预处理、编译、汇编、链接。 3．Makefile 用来描述程序或工程中各个文件之间的相互联系 4．make。命令用来及时makefile文件中的命令 5．库分为静态库和共享库。 二、简答题 1．静态库和共享库的区别 （1）静态库的代码在编译时就已连接到开发人员开发的应用程序中。 （2）共享库只是在程序开始运行时才载入，在编译时，只是简单地指定需要使用的库函数。 第十章指针 一．选择题 1.变量的指针，其含义是指该变量的。 A）值 B）地址 C）名 D）一个标志 2.已有定义int k=2;int *ptr1,*ptr2;且ptr1和ptr2均已指向变量k，下面不能正确执行的赋值语句是。 A）k=*ptr1+*ptr2 B）ptr2=k C）ptr1=ptr2 D）k=*ptr1*(*ptr2 3.若有说明：int *p,m=5,n;以下程序段正确的是。 A）p=&n ; B）p = &n ; scanf(“%d”,&p; scanf(“%d”,*p; C）scanf(“%d”,&n; D）p = &n ; *p=n ; *p = m ; 4.已有变量定义和函数调用语句：int a=25;print_value(&a;下面函数的输出结果是。 void print_value(int *x { printf(“%d\n”,++*x; } A）23 B）24 C）25 D）26 5.若有说明：int *p1, *p2,m=5,n;以下均是正确赋值语句的选项是。 A）p1=&m; p2=&p1 ; B）p1=&m; p2=&n; *p1=*p2 ; C）p1=&m; p2=p1 ; D）p1=&m; *p1=*p2 ; 6.若有语句：int *p,a=4;和p=&a；下面均代表地址的一组选项是。 A）a,p,*&a B）&*a,&a,*p C）*&p,*p,&a D）&a,&*p,p 7.下面判断正确的是。 A）char *a=”china”; 等价于char *a; *a=”china” ; B）char str[10]={“china”}; 等价于char str[10]; str[ ]={“china”;} C语言中不同类型的结构体的指针间可以强制转换，很自由，也很危险。只要理解了其内部机制，你会发现C是非常灵活的。 一. 结构体声明如何内存的分布， 结构体指针声明结构体的首地址， 结构体成员声明该成员在结构体中的偏移地址。 变量的值是以二进制形式存储在内存中的，每个内存字节对应一个内存地址，而内存存储的值本身是没有整型，指针，字符等的区别的，区别的存在是因为我们对它们有不同的解读，param的值就是一个32位值，并且存储在某个内存单元中，通过这个32位值就能找到param所指向的结构的起始地址，通过这个起始地址和各个结构所包含变量离起始地址的偏移对这些变量进行引用， param->bIsDisable只是这种引用更易读的写法，只要param是指向 PAINT_PARAM的指针，那么param的值就肯定存在，param存在，偏移量已知，那么param->bIsDisable就肯定存在，只是要记住，param->bIsDisable只是代表了对param一定偏移地址的值。 不是说某个地址有那个结构体你才能引用，即使没有，你也能引用，因为你已经告诉了编译器param变量就是指向一个PAINT_PARAM结构体的变量并且指明了param的值，机器码的眼中是没有数据结构一说的，它只是机械的按照 指令的要求从内存地址取值，那刚才的例子来说，peg->x,peg->y的引用无论 0x30000000是否存在一个eg结构体都是合法的，如果0x30000000开始的8 个字节存在eg结构体，那么引用的就是这个结构体的值，如果这个位置是未定义的值，那么引用的结果就是这8个字节中的未定义值，内存位置总是存在的，而对内存中值的引用就是从这些内存位置对应的内存单元取值。 举个例子: typedefstruct_eg { int x； int y； }eg; 习题7 一 单选题 1.设有如下定义，则表达式sizeof(y)的值是【 】。 struct data {long *ln; char c; struct data *last,*next; }y; A.7 B.9 C.13 D.17 【答案】C 【解析】指针变量在内存中占用4个字节，所以sizeof(y)的值是4+1+4+4=13 2.设有以下程序段，则表达式的值不为100的是【 】。 struct st {int a;int *b;}; void main() {int m1[]={10,100},m2[]={100,200}; struct st *p,x[]={99,m1,100,m2}; p=x; ... } A.*(++p->b) B.(++p)->a C.++p->a D.(++p)->b 【答案】D 【解析】根据题意，p 指向x 数组，x[0]的b 成员指向m1数组，x[1]的b 成员指向m2数组，如图7-1所示。选项A 中p->b 指向m1[0]，通过“++”运算p->b 指向m1[1]，所以选项A 的表达式的值为100。选项B 中++p 使p 指向x[1]，x[1]的a 成员的值是100。选项C 中p 指向x[0]，x[0]的a 成员做“++”运算，结果为100。选项D 中++p 使p 指向x[1]，x[1]的b 成员的值是指针，所以选择选项D 。 m1m2p 图7-1 3.设有以下定义，且如图7-2所示，指针head 和p 指向链表的第一个结点，指针q 指向新的结点，则不能把新结点插入在第一个结点之前的语句是【 】。 head p q 图7-2 struct node {int a; struct node *next; }*head,*p,*q; A.head=q,q->next=p; B.head=q,q->next=head; C.q->next=head,head=q; D.head=q,head->next=p; 【答案】B 4.设有如下结构体说明和变量定义，且如图7-3所示，指针p指向变量one，指针q指向变量two，则不能将结点two接到结点one之后的语句是【】。 p 图7- 3 struct node {int n; struct node *next; }one,two,*p=&one,*q=&two; A.p.next=&two; B.(*p).next=q; C.one.next=q; D.p->next=&two; 【答案】A 【解析】p是指向结构体的指针，因此选项D是规范的引用方式。 5.设有以下定义，且如图7-4所示建立了链表，指针p、q分别指向相邻的两个结点，下列语句中【】不能将p所指向的结点删除。 head...... 图7- 4 struct node {int a; struct node *link; }*head,*p,*q; A.q->link=p->link; B.p=p->link,q->link=p; C.(*p).link=(*q).link; D.p=(*p).link,(*q).link=p; 【答案】C 6.以下选项中，能正确地将x定义为结构体变量的是【】。 指针 1.在主函数中输入一个字符串str，调用函数统计字符串中出现的字母（含大 小写）、数字、空格及其他字符出现的次数，在主函数中输出统计结果。要求写三个版本的程序：（1）用指针作参数返回统计结果。（2）用引用做参数返回统计结果(引用做参数效率更高，代码更简单。)（3）用数组做参数返回统计结果(当返回多个同类型结果时用数组做参数更简单)。 1.#include 第七章结构体 一. 单项选择题 1.设有定义 Struct{int x; int y;}d[2]={{1,3},{2,7}}; 则printf(“%d\n”,d[0].y/d[0].x*d[1].x);的输出是（） A.0 B.1 C.3 D.6 2.根据下面的定义，能打印出字母M的语句是（） struct person {char name[9]；int age；}； struct person c[10] = {{“John”，17 }，{“Paul”，19 }，{“Mary”，18 }，{“Adam”，16 }}； A.printf （“%c”，c[3].name）； B.printf （“%c”，c[3].name[1] ）； C.printf（“%c”，c[2].name[1]）； D.printf（“%c”，c[2].name[0] ）； 3. 设有如下定义，则对data 中的a 成员的正确引用是（） struct sk{int a；float b；} data，*p＝& data； A. (*p).data.a B. (*p).a C. p->data.a D. p.data.a 二. 填空题： 1. 设有定义“struct {int a；float b；char c；}abc，*p_abc＝&abc；”，则对结构体成员a 的引用方法可以是abc_________a 和p_abc___________a. 2. 若有以下说明和定义语句，假设int类型占内存2个字节，则结构体变量w 在内存中所占的字节数是__________. struct st { int v[3]；char w[5]；double ave；}w； 3.阅读下列程序，写出程序的运行结果。 main （） { struct student { char name[10]； float k1； float k2； } a[2]＝{ {“zhang”，100，70} ，{“wang”，70，80 } }，* p＝a； int i； printf（“\nname：%s total＝%f”，p ->name，p ->k1＋p -> k2）； printf（“\nname：%s total＝%f”，a[l].name，a[1].k1＋a[l].k2）； } 函数 (一)选择题 1.以下正确的说法是_________. 建立函数的目的之一是a)提高程序的执行效率 b)提高程序的可读性 c)减少程序的篇幅 d)减少程序文件所占存 2．以下正确的函数原型声明形式是________. a)double fun(int x,int y) b)double fun(int x; int y) c)double fun(int x, int y); d)double fun(int x,y); 3．C语言规定，简单变量做实参时，它和对应形参之间的数据传递方式为______. A)地址传递 B）单向值传递 C）由实参传给形参，再由形参传回给实参 D）由用户指定传递方式 4．C语言允许函数值类型缺省定义，此时该函数值隐含的类型是______. a)float b)int c)long d)double 5．已有以下数组定义和f函数调用语句，则在f函数的说明中，对形参数组array 的错误定义方式为________. int a[3][4]; f(a); a)f(int array[][6]) b)f(int array[3][]) c)f(int array[][4]) d)f(int array[2][5]) 6．以下程序的正确运行结果是_________. #include 第十章结构体和共用体一、选择题 1．说明一个结构体变量时系统分配给它的内存是（A）。 A）各成员所需内存总和。 B）结构中第一个成员所需的内存量 C）成员中占内存量最大者所需的容量 D）结构中最后一个成员所需内存量 2．以下对结构体类型变量的定义中不正确的是（D）。 A) #define STUDENT struct student STUDENT { int num; float age; } std1; B) struct student { int num; float age; } std1; C) struct { int num; float age; }std1; D) struct { int num; float age; } student; struct student std1; 3．设有以下说明语句 struct stu { int a; float b; } stutype; 则下面的叙述不正确的是（C）。 A）struct是结构体类型的关键字 B）s truct stu是用户定义的结构体类型 C）s tutype是用户定义的结构体类型名 D）a和b都是结构体成员名 4．C语言结构体类型变量在程序执行期间（A） A）所有成员一直驻留在内存中 B）只有一个成员驻留在内存中 C）部分成员驻留在内存中 D）没有成员驻留在内存中 5．以下程序运行结果是（A）。 #include “stdio.h” main() { struct date { int year, month, day; } today; printf(“%d\n”,sizeof(struct date)); A) 6 B)8 C)10 D)12 6．下面程序的运行结果是（D） 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); } A)0 B)1 C)3 D)6 7．以下scanf函数调用语句中对结构体变量成员的不正确引用是（D）struct pupil { char name[20]; int age; int sex; } pup[5],*p; p=pup; A)scanf(“%s”,pup[0].name); B)scanf(“%d”,&pup[0].age); C)scanf(“%d”,&(p->sex)); D)scanf(“%d”, p->age); 8．设有如下的定义： struct sk { int n; float x; } data, * p; 若要使p指向data中的n域，正确的赋值语句是（C）。 A）p=&data.n; B）*p=data.n; C）p=(struct sk *)&data.n D）p=(struct sk*) data.n; 9．若有以下说明语句 struct student 一、选择题 1、一个C语言程序的执行是从（）。 A.第一个语句开始，直到最后一个语句结束 B.第一个函数开始，直到最后一个函数结束 C.main函数的第一条语句开始，直到main函数最后一条语句结束 D.main函数开始，直到最后一个函数结束 正确答案：C 2、变量定以后，系统将为变量分配存储空间，double类型的静态变量（）。 A.将在编译时分配4个字节的存储空间 B.将在编译时分配8个字节的存储空间 C.将在程序执行时分配4个字节的存储空间 D.将在程序执行时分配8个字节的存储空间 正确答案：B 3、设int x=8, y;执行y=x++;后，变量x、y的值分别是（）。 A.8,8 B.8,9 C.9,8 D.9,9 正确答案：C 4、对于整数n=378，表达式n%10和n/10的值分别是（）。 A.3,8 B.8,3 C.37,8 D.8,37 正确答案：D 5、与p!=0等价的表达式是（）。 A.p B.p==1 C.p=1 D.!p=0 正确答案：A 6、已定义：int a[5];则数组a可引用的元素有（）。 A.a[1]~a[5] B.a[0]~a[5] C.a[1]~a[4] D.a[0]~a[4] 正确答案：D 7、已知char str[20],str1[10]="China", str2[10]="Russia" ;将str1和 str2 中存放的字符串交换的正确操作是（）。 A.str=str1 ; str1=str2 ; str2=str; B.str1= str1+str2 ; str2= str1-str2; str1= str1-str2; C.strcat(str1,str2) ; str2= str1-str2; str1= str1-str2; D.strcpy(str,str1) ; strcpy(str1,str2) ; strcpy(str2,str) ; 正确答案：D 8、若有语句：int a [4],*p=a; ，下面均代表地址的一组选项是（）。 A.a，p，a[0] B.a，p，++p C.&a，*p，p[0] D.*a，p++，&a[0] 正确答案：B 9、若有以下定义语句，则以下错误的引用是（）。 struct student{ int num,age;}; struct student stu[3]={{101,20},{102,19},{103,18}},*p=stu; 题目内容： 定义一个学生的结构体，包含姓名，年龄，身高从键盘输入一组学生信息 结果打印4组数据 输入样例 Tom 20 1.70 输出 Tom0 20 1.70 Tom1 21 1.71 Tom2 22 1.72 Tom3 23 1.73 输入描述 从键盘输入一组学生信息 结果打印3组数据 输入样例 Tom 20 1.70 输出描述 结果打印4组数据 输出 Tom0 20 1.70 Tom1 21 1.71 Tom2 22 1.72 Tom3 23 1.73 输入样例 Tom 20 1.70 输出样例 Tom0 20 1.70 Tom1 21 1.71 Tom2 22 1.72 Tom3 23 1.73 程序代码 for(i=0;i<4;i++) printf("%s%d %d %.2f\n",https://www.doczj.com/doc/cc5946170.html,,i,a.age+i,a.high+i *0.01); return 0; } 2.c-05-1 回文句子 (10分) C时间限制：3000 毫秒 | C内存限制：3000 Kb 题目内容： "回文句"是一种句型，一个句子如果正着读与倒着读的意思一样，就可以称为"回文句"。 如：蜜蜂酿蜂蜜；风扇能扇风；奶牛产牛奶；清水池里池水清；静泉山上山泉；上海自来水来自海上；雾锁山头山锁雾；天连水尾水连天；门盈喜气喜盈门。 在英文中也是有回文的，而且是一种非常有趣的修辞，即palindrome，其结构跟中文是 一个道理。英文回文举例： Able was I ere I saw Elba。(在我看到厄尔巴岛之前，我曾所向无敌) Madam, I' m Adam.(女士, 我是Adam) Was it a bar or a bat I saw? (我看到的是酒吧还是蝙蝠？) 编写一个函数，判断给定英文句子是不是回文句。 输入描述 输出描述 输入样例 输入样例1: Madam, I' m Adam. 输入样例2: C语言程序设计(第7章结构体与共用体)2 7.2 结构体数组的定义和引用 单个的结构体类型变量在解决实际问题时作用不大，一般是以结构体类型数组的形式出现。结构体类型数组的定义形式为： struct stu /*定义学生结构体类型*/ { char name[20]; /*学生姓名*/ char sex; /*性别*/ long num; /*学号*/ float score[3]; /*三科考试成绩*/ }; struct stu stud[20]; /* 定义结构体类型数组stud ，*/ / *该数组有2 0个结构体类型元素* / 其数组元素各成员的引用形式为： stud[0].name 、stud[0].sex、stud[0].score[i]; stud[1].name、stud[1].sex、stud[1].score[i]; . . . . . . stud[19].name、stud[19].sex、stud[19].score[i]; [例7-1] 设某组有4 个人，填写如下的登记表，除姓名、学号外，还有三科成绩，编程实现对表格的计算，求解出每个人的三科平均成绩，求出四个学生的单科平均，并按平均成绩由高分到低分输出。 NumberNameEnglishMathemrPhysicsAverage 1Liping789876. 2Wanglin669086. 3Jiangbo897076. 4Yangming9010067. 题目要求的问题多，采用模块化编程方式，将问题进行分解如下： 1) 结构体类型数组的输入。 2) 求解各学生的三科平均成绩。 3) 按学生的平均成绩排序。 4) 按表格要求输出。 5) 求解组内学生单科平均成绩并输出。 6) 定义m a i n ( )函数，调用各子程序。 第一步，根据具体情况定义结构体类型。 struct stu { char name[20]; /*姓名* / long number; /*学号* / float score[4]; /* 数组依此存放English、Mathema、Physics，及Average*/ } ; 由于该结构体类型会提供给每个子程序使用，是共用的，所以将其定义为外部的结构体类型，放在程序的最前面。 第二步，定义结构体类型数组的输入模块。 void input(arr,n) /*输入结构体类型数组arr 的n个元素*/ struct stu arr[]; int n; { int i,j; char temp[30]; for (i=0;i { printf("\ninput name,number,English,mathema,physic\n"); /*打印提示信息* / gets(arr[i].name); /* 输入姓名*/ gets(temp); /* 输入学号*/ arr[i].number = atol(temp); 第14章结构体、共用体和用户定义类型 三、编程题 14.12设有以下结构类型的说明： struct stud { charnum[5], name[10]; int s[4]; doubleave; }; 请编写： (1) 函数readrec：把30名学生的学号、姓名、四项成绩以及平均分放在一个结构体数组中，学生的学号、姓名和四项成绩由键盘输入，然后计算出平均分放在结构体对应的域中。 (2) 函数writerec：输出30名学生的记录。 (3) main函数调用readrec函数和writerec函数，实现全部程序功能(注：不允许使用外部变量，函数之间的数据全部使用参数传递)。 #include } st[i].ave=ave/4.0; } } voidwriterec(struct stud st[],int n) { inti,j; for(i=0;i结构体指针
C语言程序设计(第7章结构体与共用体)3
第十一章结构体的试题
第七章结构体
结构体的指针应用
指针和结构体练习题
第14章习题参考答案
指针和结构体练习题.
C语言中不同的结构体类型的指针间的强制转换详解
教材课后题答案-第7章
指针与结构体 上机
第七章 结构体
函数、指针与结构体练习题_参考答案
第七章 结构体和共用体
C语言 第七章 结构体期末测试习题与答案
结构指针
C语言程序设计(第7章结构体与共用体)2
c语言第14章书后习题_编程题
相关主题
文本预览