在实际的处理对象中，有许多信息是由多个不同类型的数据组合在一起进行描述，而且这些不同类型的数据是互相联系组成了一个有机的整体。此时，就要用到一种新的构造类型数据——结构体（structure），简称结构。结构体的使用为处理复杂的数据结构（如动态数据结构等）提供了有效的手段，而且，它们为函数间传递不同类型的数据提供了方便。
结构体类型的定义：
定义一个结构体类型的一般形式为：
struct 结构体名
{
数据类型成员名1；
数据类型成员名2；
.
.
.
数据类型成员名n；
}；
在大括号中的内容也称为“成员表列”或“域表”。其中，每个成员名的命名规则与变量名相同；数据类型可以是基本变量类型和数组类型，也可以是指针变量类型，或者是一个结构体类型，用分号“；”作为结束符。整个结构的定义也用分号作为结束符。
例如：定义一个职工worker结构体如下：
struct worker
{ int number;
char name[20];
char sex; //sex是成员名
int age;
float salary;
char address[80];
char phone[20];
}; //注意分号不要省略
int sex=10; //sex是变量名
结构体类型中的成员名可以与程序中的变量名相同，二者并不代表同一对象，编译程序可以自动对它们进行区分。
最后，总结一下结构体类型的特点：
（1）结构体类型是用户自行构造的。
（2）它由若干不同的基本数据类型的数据构成。
（3）它属于C++语言的一种数据类型，与整型、实型相当。因此，定义它时不分配空间，只有用它定义变量时才分配空间。
结构体变量的定义：
结构体只是用户自定义的一种数据类型，因此要通过定义结构体类型的变量来使用这种类型。通常有三种形式来定义一个结构体类型变量，分别说明如下：
1.先定义结构体类型，在利用类型定义结构体变量。这是C++语言中定义结构体类型变量最常见的方式，一般语法格式如下：
struct 结构体名
{
成员表列；
}；
struct 结构体名变量名；
例如，定义几个职工变量：
struct worker
{
int number;
char name[20];
char sex;
int age;
float salary;
char address[80];
char phone[20];
};
struct worker worker1,worker2;
或者可以简写为：
worker worker1,worker2;
注意：“struct worker”代表类型名,用worker代表该类型也是可以的。
为了使用上的方便，程序员通常用一个符号常量代表一个结构体类型。即在程序开头加上下列语句：
#define WORKER struct worker
这样在程序中，WORKER与struct worker完全等效。
2.在定义类型的同时定义变量
这种形式的定义的一般形式为：
struct 结构体名
{
成员表列；
}变量名；
如：
struct worker
{
int number;
char name[20];
char sex;
int age;
float salary;
char address[80];
char phone[20];
}worker1,worker2;
3,不定义结构体类型而直接定义结构体变量：
struct //此处没有给出结构体名
{
成员表列；
}变量名；
struct
{
int number;
char name[20];
char sex;
int age;
float salary;
char address[80];
char phone[20];
}worker1,worker2;
这种方法并不实用。
结构体变量定义了以后，我们可以用sizeof来求它占的空间大小。
Sizeof求得是结构体所有成员变量的空间之和。
如：
Struct user
{
Int ID;
Int age;
}person;
Cout< //输出8. 结构体变量的成员： 引用结构体变量的成员的格式为： 结构体变量.成员变量名 如结构体变量work有7个成员变量，分别是： worker1.number； https://www.doczj.com/doc/c016668534.html,； worker1.sex； worker1.age； worker1.salary； worker1.address； worker1.phone 在定义了结构体变量后，就可以用不同的赋值方法对结构体变量的每个成员赋值。例如：strcpy(https://www.doczj.com/doc/c016668534.html,,”Zhang San”); worker1.age=26; strcpy(worker1.phone,”1234567”); worker1.sex=’m’; : : 除此之外，还可以引用结构体变量成员的地址以及成员中的元素。例如：引用结构体变量成员的首地址&https://www.doczj.com/doc/c016668534.html,；引用结构体变量成员的第二个字符https://www.doczj.com/doc/c016668534.html,[1]；引用结构体变量的首地址&worker1。 在使用结构体类型变量时有以下几点需要加以注意： （1）不能将一个结构体类型变量作为一个整体加以引用，而只能对结构体类型变量中的各个成员分别引用。 例如，对上面定义的结构体类型变量wan，下列引用都是错误的： cout< cin>>wan; 但是可以如下引用： cout< cin>>https://www.doczj.com/doc/c016668534.html,; （2）如果成员本身又属一个结构体类型，则要用若干个成员运算符，一级一级地找到最低的一级成员。只能对最低级的成员进行赋值或存取以及运算。例如，对上面定义的结构体类型变量worker1，可以这样访问各成员： worker1.age https://www.doczj.com/doc/c016668534.html, worker1.birthday. year worker1.birthday. month worker1.birthday. day 注意：不能用worker1.birthday来访问worker1变量中的成员birthday，因为birthday 本身是一个结构体变量。 （3）对成员变量可以像普通变量一样进行各种运算（根据其类型决定可以进行的运算）。例如： worker2.age=worker1.age; sum=worker1.age+worker2.age; worker1.age++; （4）在数组中，数组是不能彼此赋值的，而结构体类型变量可以相互赋值。 在C++程序中，同一结构体类型的结构体变量之间允许相互赋值，而不同结构体类型的结构体变量之间不允许相互赋值，即使两者包含有同样的成员。 结构体变量的初始化： 1.在定义结构体变量的同时即对其进行初始化： struct student { char name[10]; int number; }; student stu1={"zhangsan",20110101}; student stu2={"lisi",20110102},stu3={"wangwu",20110103}; 2.分别对结构体的成员变量初始化： student stu1,stu2,stu3; https://www.doczj.com/doc/c016668534.html,=”zhangsan”;//此处有错，因为name为数组，不能这样赋值。 strcpy(https://www.doczj.com/doc/c016668534.html,,”zhangsan”); stu.number=20110101; 3.用其他同类型的结构体来初始化。 student stu1={"zhangsan",20110101}; student stu2=stu1;//可以用stu1来初始化stu2，即使stu1中包含数组成员。 例1：给出每个同学的语文、数学、英语成绩，输出他们的总分。 输入：第一行，一个整数n，表示n个同学。 从第二行开始到第n+1行，每行一个字符串，由小写字母组成，接下来三个实数，在0到100之间。 输出：n行，每行一个字符串和一个实数，用空格隔开，表示该同学的名字和总分。 要求：用结构体来实现。 #include using namespace std; struct student { Char name[20]; double yuwen,shuxue,yingyu,zongfen; }stu; int main() { int n; cin>>n; for(int i=0;i { cin>>https://www.doczj.com/doc/c016668534.html,>>stu.yuwen>>stu.shuxue>>stu.yingyu; stu.zongfen=stu.yuwen+stu.shuxue+stu.yingyu; cout< } } 问题：结构体的成员变量能否是一个结构体呢？ 当然是可以的。 但其成员的结构体类型需先定义： struct day { int year,month,day; }; struct student { char name[10]; int number; day birthday; }stu; int main() { strcpy(https://www.doczj.com/doc/c016668534.html,,”zhangsan”); number=1001; stu.birthday.year=1995,stu.birthday.month=12,stu.birthday.day=20; cout< cout< cout< } 结构体数组： 如果一个数组中的元素都是结构体，则该数组成为结构体数组。结构体数组除了其中的元素是结构体之外，和普通的数组没有什么区别。 结构体数组的定义： 1. struct student { char name[10]; int number; day birthday; }stu[100];//定义一个结构体数组。 2. struct student { char name[10]; int number; day birthday; }; student stu[100];//定义一个结构体数组。 结构体数组的初始化，和普通数组的初始化是一样的。 可以在定义数组的同时用{}赋值 例如： struct day { int year,month,day; }; struct student { char name[10]; day birthday; }; int main() { student stu[2]={{"zhangsan",{1993,12,24}},{"lisan",{1995,12,25}}}; cout< cout< } 不过，对于结构体的每个元素，都应该用{}括起来，如果是结构体的某个成员是结构体，该成员的值也应该用{}括起来。 也可以对结构体中的每个成员变量依次赋值。 struct day { int year,month,day; }; struct student { char name[10]; day birthday; }stu[2]; int main() { strcpy(stu[0].name,"zhangsan"); stu[0].birthday.year=1992; stu[0].birthday.month=10; stu[0].birthday.day=29; cout< } 一个结构体数组的元素相当于一个结构体变量，因此前面介绍的有关结构体变量的 规则也适应于结构体数组元素。以上面定义的结构体数组stu[3]为例说明对结构体数组的引用： （1）引用某一元素中的成员。 若要引用数组第二个元素的name成员，则可写为： stu[1].name 若数组已如前所示进行了初始化，则stu[1].name的值为“Liu Yong”。 （2）可以将一个结构体数组元素值赋给同一结构体类型的数组中的另一个元素，或赋给同一类型的变量。如： struct student stu[3],student1; 现在定义了一个结构体类型的数组，它有3个元素，又定义了一个结构体类型变量student1，则下面的赋值是合法的。 student1=stu[0]; stu[0]=stu[1]; stu[1]=student1; （3）不能把结构体数组元素作为一个整体直接进行输入输出。如： cout< 或 cin>>stu[0]; 都是错误的。 只能以单个成员为对象进行输入输出，如： cin>>stu[0].name; cin>>stu[1].num; cout< cout< 结构体指针： 通常把指向结构体变量的指针称为结构体指针。 可以设一个指针变量用来指向一个结构体变量，此时该指针变量的值是结构体变量的起始地址，该指针称为结构体指针。结构体指针与前面介绍的各种指针变量在特性和方法上是相同的。与前述相同，在程序中结构体指针也是通过访问目标运算“*”访问它的目标结构体。 结构体指针在程序中的一般定义形式为： struct 结构体名*结构指针名； 其中的结构体名必须是已经定义过的结构体类型。 例如， student *pstu;//其中student 须是已经定义好的结构体类型。 其中pstu是指向struct student结构体类型的指针。结构体指针的说明规定了它的数据特性，并为结构体指针本身分配了一定的内存空间。但是指针的内容尚未确定，即它的具体指向是不定的。前面讲过，在程序中注意不要使用不定向的指针。因此，指针在使用之前，必须通过初始化或赋值运算把实际存在的某个结构体变量的存储地址赋给它。这时要求结构体指针与结构体变量必须属于相同的结构体类型。 当表示指针变量p所指向的结构体变量中的成员时，“（*结构体指针名）.成员名” 这种表示形式总是需要使用圆括号，显得很不简炼。因此，对于结构体指针指向的结构体成员项，给出了另外一种简洁的表示方法，如下表示： 结构体指针名->成员名 它与前一种表示方法在意义上是完全等价的。例如，结构体指针p指向的结构体变量中的成员name可以表示如下： （*p）.name 或p->name 在后种表示方法中，“->”（减号和大于号）也是一种运算符。它表示的运算意义是，访问指针指向的结构体变量中的成员。 例如： #include using namespace std; struct student { int num; int age; }stu[100],*pstu; int main() { int n; cin>>n; for(int i=0;i cin>>stu[i].num>>stu[i].age; pstu=stu; for(int i=0;i { //请用三种方式 //将所有学生的num、age输出。 cout< cout<<(pstu+i)->num<<" "<<(pstu+i)->age< cout<<(*(pstu+i)).num<<" "<<(*(pstu+i)).age< } } 链表：使用结构体指针可以构成链表，链表的每一个元素一般是个结构体，该结构体的成员包含基本的信息之外，还包含了下一个元素的地址，即一个next指针，指向下一个元素。这些元素在内存中并不一定是连续的，但是可以通过next指针找到下一个元素。这样的数据结构我们称为链表。 我们前面学习的数组，是多个同类变量的集合，他们在内存中是连续的。数组中查找元素是很方便的，但是如果要插入一个元素或删除一个元素，则需要移动后续的大量元素，这是很耗时的。而链表我们也可以把它们看做是多个同类元素的集合，只是他们在内存中并不是连续排列的。链表对于插入和删除操作是非常高效的。 例：输入n个同学的名字，将他们组成链表。 #include using namespace std; struct node { char name[10]; node *next; }; int main() { int n; cin>>n; node *head=new node; cin>>head->name; head->next=NULL; node *p=head; for(int i=1;i { node *t=new node; cin>>t->name; t->next=NULL; p->next=t; p=p->next; } for(p=head;p!=NULL;p=p->next) cout< return 0; } 设p和q为链表中相邻两个元素的指针，现在要在它们中间插入一个新的元素t，姓名为“Jack” 链表的插入操作：（在p，q之间插入一个新的元素） p q 第一步：new一个该结构体类型的变量t : t 第二步：将新元素指向q。 p q t 第三步：将p指向新元素。 p q t 注意，图中为了描述方便，将各元素直接设为p，q，t，而在实际应用中，p、q、t均为指针，指向他们所表示的对象。 node *t=new node; strcpy(t->name,"Jack"); t->next=q; p->next=t; 链表的删除操作： 如果要删除元素t，则将t的前一项的next指针直接指向t的后一项即可。 //找到t，设t的前一项为p，后一项为q。 p->next=q; 上面链表插入、删除操作的代码并不是完全正确的，比如说，当我们要将元素插入在链表的头部，或者删除的元素是链表的第一个元素，则上述代码将是错误的。 一个解决办法，就是在链表的头尾均增加一个虚拟元素，这样既可以用上述的代码了。 例1：给出n个同学的名字，他们排成一队，现在，对队伍进行n次操作。操作分两种：I 和D。I表示将某个同学插入到队伍的前边，D表示某个人出队。求m次操作后队伍的排列，输出队伍中每个人的名字。 第一行为n。 接下来为n行字符串，字符串全部由小写字母组成。 表示初始时队伍中的n个人。 接下来有一个整数m，表示有m个操作。 再接下来为m行，每行一个字符C和一个字符串S，字符和字符串之间有空格。 若C为'I',表示将名字为S的人插入队伍前部，若C为'D',则是将名字S的人删除。 #include #include #include using namespace std; struct student { char name[10]; student *next; }*head,*p; char sname[10]; int main() { int n; cin>>n; head=new student; cin>>head->name; head->next=NULL; p=head; for(int i=1;i { cin>>sname; student *q=new student; strcpy(q->name,sname); q->next=NULL; p->next=q; p=p->next; } cin>>m; for(int i=0;i { char c; cin>>c>>sname; if(c=='I') { student *q=new student; strcpy(q->name,sname); q->next=head; head=q; } else if(c=='D') { student *q=head; for(p=head;p!=NULL;p=p->next) { if(strcmp(p->name,sname)==0) { if(p!=head) q->next=p->next; else head=head->next; break; } else q=p; } } } for(student *q=head;q!=NULL;q=q->next) cout< } 循环链表：如果链表的最后一个元素的next指向的是该链表的第一个元素，则该链表形成了一个环，这种链表称为循环链表。 双向链表： 如果链表的每个元素包含一个next指针和一个prev指针，分别指向该元素的后一个元素和前一个元素，则该链表称为双向链表。 struct node { char name[10]; node *next; node *prev; }; 双向链表的生成、插入和删除类似于普通链表。 例：有n个小球，从左至右编号为1，2，……n.现在有2种移动操作: A s t 表示把小球s移动到小球t的左边。B s t 表示把小球s移动到小球t的右边。给出m次操作，求最后小球的顺序。 #include #include using namespace std; #define MAXN 100001 struct node { int num; node *next; node *prev; }*arr[MAXN];//arr[i]指向编号为i的小球. int main() { int n,m; scanf("%d%d",&n,&m); arr[0]=new node;//arr[0]为链表头部增加的虚拟元素. arr[0]->num=0; arr[0]->prev=NULL; //arr[0]->next=NULL; for(int i=1;i<=n+1;i++) {arr[i]=new node; arr[i]->num=i; arr[i-1]->next=arr[i]; arr[i]->prev=arr[i-1]; } arr[n+1]->next=NULL;//arr[n+1]为链表尾部增加的虚拟元素。 char f[3]; int s,t; for(int i=1;i<=m;i++) { scanf("%s%d%d",f,&s,&t); if(f[0]=='A')//该操作实际上有删除和插入组成 { node *q=arr[s]->prev; q->next=arr[s]->next; q->next->prev=q; //以上为删除操作 node *p=arr[t]->prev; arr[s]->next=arr[t]; arr[t]->prev=arr[s]; p->next=arr[s]; arr[s]->prev=p; //以上为插入操作 } Else //分解为删除和插入 { node *q=arr[s]->prev; q->next=arr[s]->next; q->next->prev=q; //以上为删除操作 node *p=arr[t]->next; arr[s]->next=p; p->prev=arr[s]; arr[t]->next=arr[s]; arr[s]->prev=arr[t]; //以上为插入操作 } } for(node *p=arr[0]->next;p!=NULL&&p!=arr[n+1];p=p->next) printf("%d\n",p->num); } 下面介绍了结构体的创建和使用方法： 创建过程： 定义一个名字为addr_t的结构体，其内容为名位addr的数组，数组大小为NET_ADDR_SIZE。 typedef struct { addr_t *addr;//地址 u8 *msg;//信息 u8 len;//信息长度 u8 port;//端口 } ioctlRawSend_t;//发送信息结构体 定义一个名字为ioctlRawSend_t的结构体，其内容为一个结构体，一个无符号类型指针和两个无符号数。将内容中的结构体代入这个结构体类型中，其内容可以写成（这样写只是为了看得更清晰） typedef struct { u8 addr[NET_ADDR_SIZE];//地址 u8 *msg;//信息 u8 len;//信息长度 u8 port;//端口 } ioctlRawSend_t;//发送信息结构体 这是一个联合体（共用体），很好理解，就是把两个结构体成员（ioctlRawSend_t，ioctlRawReceive_t）放在了一起用同一个名字（ioctl_info）表示，成员占用相同的内存单元，其中内容同步变化。 从变量观察窗口我们可以看到变量是如何组织在一起的。 到现在就从最基础的数组组成了一个联合体，下面我们使用它。 下面的语句中显示了如何向刚才建立的联合体中写要求的数据。 下面进行逐句分析 第一行中写广播地址（具体数字可以认为变动，一般为{0xFF,0xFF,0xFF,0xFF}）到联合体中的 发送地址中。下面是变量窗口中发生的变化（红色表示变化）。 接下来的一句为向信息中填充内容，下面是变量观察窗口的变化。其中msg只显示0号元素，是因为它是一个指针，指向的是首地址，其实其他的内容也已经变化。 算并输出每个人的学号和平均成绩。 2.已知链表结点结构如下，假设动态链表已经建立,请编写删除给定学号的结点的函 数。(只编写删除子函数即可) 3.编写函数实现动态链表的建立。链表结点结构如下,要求在主函数中将你所建立的链 表输出到屏幕上。 4.有10个学生,每个学生的信息包括学号、姓名、3门课的成绩，从键盘输入10个学 生数据存入结构体数组中,要求输出个人总分最高的学生的信息(包括学号、姓名、3门课成绩、总分)。 5.链表的结点数据类型如下： struct node{ int data; struct node *next; }; 链表的建立和输出函数如下，编写将第i个结点删除的函数，并完善主函数，调试运行整个程序。 struct node *creat() { int x; struct node *h,*s,*r; h=(struct node *)malloc(sizeof(struct node)); r=h; scanf("%d",&x); while(x!=-1) { s=(struct node*)malloc(sizeof(struct node)); s->data=x; r->next=s; r=s; scanf("%d",&x); } r->next=NULL; return h; } void print(struct node *h) //打印函数 { struct node *p; p=h->next; if(p==NULL) printf("list is empty!"); else { while(p!=NULL) { printf("%4d",p->data); p=p->next; } } } 结构是一种用关键字struct声明的自定义数据类型。与类相似，也可以包含构造函数，常数，字段，方法，属性，索引器，运算符和嵌套类型等，不过，结构是值类型。 1.结构的构造函数和类的构造函数不同。 2. a.结构不能包含显式的无参数构造函数。结构成员讲自动初始化为它们的默认值。 b.结构不能包含以下形式的初始值设定类：base（argument-list）； 2.对于结构中的实例字段成员，不能在声明时赋值初始化。 3.声明了结构类型后，可以使用new运算符创建构造对象，也可以不使用new关键字。如果不使用new，那么在初始化所有字段之前，字段将保持未赋值状态且对象不可用。 4.结构不支持继承，即一个结构不能从另一个结构或类继承，而且不能作为一个类的基类。但是，结构从基类OBJECT继承。结构也可以实现接口。 5.什么时候用结构呢？结构使用简单，并且很有用，但是要牢记：结构在堆栈中创建，是值类型，而类是引用类型。每当需要一种经常使用的类型，而且大多数情况下该类型只是一些数据时，使用结构能比使用类获得更佳性能。 结构是值类型，所以会影响性能，但根据使用结构的方式，这种影响可能是正面的，也可能是负面的。正面的影响是为结构分配内存时，速度非常快，因为它们将内联或者保存在堆栈中。在结构超出了作用域被删除时，速度也很快。另一方面，只要把结构作为参数来传递或者把一个结构赋给另一个结构(例如A=B，其中A和B是结构)，结构的所有内容就被复制，而对于类，则只复制引用。这样，就会有性能损失，根据结构的大小，性能损失也不同。注意，结构主要用于小的数据结构。但当把结构作为参数传递给方法时，就应把它作为ref参数传递，以避免性能损失——此时只传递了结构在内存中的地址，这样传递速度就与在类中的传递速度一样快了。另一方面，如果这样做，就必须注意被调用的方法可以改变结构的值。 class和struct有且仅有一个区别，那就是对于class说明的类成员，函数也好，变量也好，如果没有指定类型，缺省是private限定的。而对于struct,则是public的。 结构体数组效率比类数组效率高（不需要装箱合拆箱）。结构体集合（如Hashtable）效率比类集合效率低。集合的元素是引用类型，所以结构体必须进行装箱和拆箱处理。所以类在大的集合中更有效率。 类和结构体的区别 1. class和structure很相似,从技术层面讲,class是引用,而 structure则是数值.有人很形象的说 class里有行动,方法,成员,是有机体的结合，而structure则是活生生的有机体, 2. 通俗的理解,class包涵structure, class里有方法拉，成员 拉,什么滴, 而structure只有数据, 二 .类与结构的差别 %%%类成员默认是private，而结构体默认是 public。 1.值类型与引用类型 结构是值类型：值类型在堆栈上分配地址，所有的基类型都是结构类型，例如：int 对应System.int32 结构，string 对 应 system.string 结构，通过使用结构可以创建更多的值类 型 类是引用类型：引用类型在堆上分配地址 堆栈的执行效率要比堆的执行效率高，可是堆栈的资源有限，不适合处理大的逻辑复杂的对象。所以结构处理作为基类型对待的小对象，而类处理某个商业逻辑 因为结构是值类型所以结构之间的赋值可以创建新的结构，而类是引用类型，类之间的赋值只是复制引用 注： 1.虽然结构与类的类型不一样，可是他们的基类型都是对象 （object）,c#中所有类型的基类型都是object 2.虽然结构的初始化也使用了New 操作符可是结构对象依然分 配在堆栈上而不是堆上，如果不使用“新建”(new)，那么在初始化所有字段之前，字段将保持未赋值状态，且对象不可用 2．继承性 结构：不能从另外一个结构或者类继承，本身也不能被继承，虽然结构没有明确的用sealed声明，可是结构是隐式的sealed . 类：完全可扩展的，除非显示的声明sealed 否则类可以继承其 第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 7．定义以下结构体类型 struct student { char name[10]; int score[50]; float average; }stud1; 则stud1占用内存的字节数是【】。 A) 64 B) 114 C) 228 D) 7 9、设有一结构体类型变量定义如下： struct date { int year; int month; int day; }; struct worklist { char name[20]; char sex; struct date birthday; } person; 若对结构体变量person的出生年份进行赋值时，下面正确的赋值语句是。。。。 A. year=1976 B. birthday.year=1976 C. person.birthday.year=1976 D. person.year=1976 1、若程序中有以下的说明和定义： struct abc { int x;char y; } 花括号后少了分号。 struct abc s1,s2; 则会发生的情况是______。 A) 编译时错B) 程序将顺序编译、连接、执行C) 能顺序通过编译、连接、但不能执行D) 能顺序通过编译、但连接出错 什么是结构体？ 简单的来说，结构体就是一个可以包含不同数据类型的一个结构，它是一种可以自己定义的数据类型，它的特点和数组主要有两点不同，首先结构体可以在一个结构中声明不同的数据类型，第二相同结构的结构体变量是可以相互赋值的，而数组是做不到的，因为数组是单一数据类型的数据集合，它本身不是数据类型(而结构体是)，数组名称是常量指针，所以不可以作为左值进行运算，所以数组之间就不能通过数组名称相互复制了，即使数据类型和数组大小完全相同。 定义结构体使用struct修饰符，例如： struct test { float a; int b; }; 上面的代码就定义了一个名为test的结构体，它的数据类型就是test，它包含两个成员a和b，成员a的数据类型为浮点型，成员b的数据类型为整型。由于结构体本身就是自定义的数据类型，定义结构体变量的方法和定义普通变量的方法一样。 test pn1; 这样就定义了一个test结构体数据类型的结构体变量pn1，结构体成员的访问通过点操作符进行，pn1.a=10 就对结构体变量pn1的成员a进行了赋值操作。注意:结构体生命的时候本身不占用任何内存空间，只有当你用你定义的结构体类型定义结构体变量的时候计算机才会分配内存。 结构体，同样是可以定义指针的，那么结构体指针就叫做结构指针。 结构指针通过->符号来访问成员，下面我们就以上所说的看一个完整的例子： #include 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; 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, ...; 如果省略结构名, 则称之为无名结构, 这种情况常常出现在函数内部, 用这 种结构时前面的例子变成: 类与结构体的区别 区别有三: 1: 类可以继承,结构不可以. 2: 类是引用类型,结构是值类型 3: 类在堆中,结构在栈分配内存 二 .类与结构的差别 1.值类型与引用类型 结构是值类型：值类型在堆栈上分配地址，所有的基类型都是结构类型，例如：int 对应System.int32 结构，string 对应 system.string 结构，通过使用结构可以创建更多的值类型 类是引用类型：引用类型在堆上分配地址 堆栈的执行效率要比堆的执行效率高，可是堆栈的资源有限，不适合处理大的逻辑复 杂的对象。所以结构处理作为基类型对待的小对象，而类处理某个商业逻辑 因为结构是值类型所以结构之间的赋值可以创建新的结构，而类是引用类型，类之间 的赋值只是复制引用 注： 1.虽然结构与类的类型不一样，可是他们的基类型都是对象（object）,c#中所有类 型的基类型都是object 2.虽然结构的初始化也使用了New 操作符可是结构对象依然分配在堆栈上而不是堆上，如果不使用“新建”(new)，那么在初始化所有字段之前，字段将保持未赋值状态，且对 象不可用 2．继承性 结构：不能从另外一个结构或者类继承，本身也不能被继承，虽然结构没有明确的用sealed声明，可是结构是隐式的sealed . 类：完全可扩展的，除非显示的声明sealed 否则类可以继承其他类和接口，自身也 能被继承 注：虽然结构不能被继承可是结构能够继承接口，方法和类继承接口一样 例如:结构实现接口 interface IImage { void Paint(); } struct Picture : IImage { public void Paint() { // painting code goes here } private int x, y, z; // other struct members } 3．内部结构： 结构： 没有默认的构造函数，但是可以添加构造函数 没有析构函数 没有abstract和sealed(因为不能继承) 不能有protected修饰符 可以不使用new初始化 在结构中初始化实例字段是错误的 类： 有默认的构造函数 有析构函数 可以使用abstract和sealed 有protected修饰符 必须使用new初始化 ?结构体类型定义 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 结构体名结构体变量名； ?注意： 结构变量的存储类型概念、它的寿命、可见 性及使用范围与普通变量、数组等完全一致。 结构体变量说明必须在结构类型定义之后， 二者也可同时进行。 matlab中使用结构体 结构(struct)数组 要在MALTAB中实现比较复杂的编程，就不能不用struct类型。而且在MATLAB中实现struct比C中更为方便。 4. 3.1 结构数组的创建 MATLAB提供了两种定义结构的方式：直接应用和使用struct函数。 1. 使用直接引用方式定义结构 与建立数值型数组一样，建立新struct对象不需要事先申明，可以直接引用，而且可以动态扩充。比如建立一个复数变量x： x.real = 0; % 创建字段名为real，并为该字段赋值为0 x.imag = 0 % 为x创建一个新的字段imag，并为该字段赋值为0 x = real: 0 imag: 0 然后可以将旗动态扩充为数组： x(2).real = 0; % 将x扩充为1×2的结构数组 x(2).imag = 0; 在任何需要的时候，也可以为数组动态扩充字段，如增加字段scale：x(1).scale = 0; 这样，所有x都增加了一个scale字段，而x(1)之外的其他变量的scale字段为空： x(1) % 查看结构数组的第一个元素的各个字段的内容 ans = real: 0 imag: 0 scale: 0 x(2) % 查看结构数组的第二个元素的各个字段的内容，注意没有赋值的字段为空 ans = real: 0 imag: 0 scale: [] 应该注意的是，x的real、imag、scale字段不一定是单个数据元素，它们可以是任意数据类型，可以是向量、数组、矩阵甚至是其他结构变量或元胞数组，而且不同字段之间其数据类型不需要相同。例如： clear x; x.real = [1 2 3 4 5]; x.imag = ones(10,10); 数组中不同元素的同一字段的数据类型也不要求一样： x(2).real = '123'; x(2).imag = rand(5,1); 第九章使用结构体类型处理组合数据 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 区别有三: 1: 类可以继承,结构不可以. 2: 类是引用类型,结构是值类型 3: 类在堆中,结构在栈分配内存 二 .类与结构的差别 1.值类型与引用类型 结构是值类型：值类型在堆栈上分配地址，所有的基类型都是结构类型，例如：int 对应System.int32 结构，string 对应 system.string 结构，通过使用结构可以创建更多的值类型 类是引用类型：引用类型在堆上分配地址 堆栈的执行效率要比堆的执行效率高，可是堆栈的资源有限，不适合处理大的逻辑复杂的对象。所以结构处理作为基类型对待的小对象，而类处理某个商业逻辑 因为结构是值类型所以结构之间的赋值可以创建新的结构，而类是引用类型，类之间的赋值只是复制引用 注： 1.虽然结构与类的类型不一样，可是他们的基类型都是对象（object）,c#中所有类型的基类型都是object 2.虽然结构的初始化也使用了New 操作符可是结构对象依然分配在堆栈上而不是堆上，如果不使用“新建”(new)，那么在初始化所有字段之前，字段将保持未赋值状态，且对象不可用 2．继承性 结构：不能从另外一个结构或者类继承，本身也不能被继承，虽然结构没有明确的用sealed声明，可是结构是隐式的 sealed . 类：完全可扩展的，除非显示的声明sealed 否则类可以继承其他类和接口，自身也能被继承 注：虽然结构不能被继承可是结构能够继承接口，方法和类继承接口一样 例如:结构实现接口 interface IImage { void Paint(); } struct Picture : IImage { public void Paint() { // painting code goes here } private int x, y, z; // other struct members } 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#中结构体和类的比较 区别： 结构是一种用关键字struct声明的自定义数据类型。与类相似，也可以包含构造函数，常数，字段，方法，属性，索引器，运算符和嵌套类型等，不过，结构是值类型。 1.结构的构造函数和类的构造函数不同。 a.结构不能包含显式的无参数构造函数。结构成员讲自动初始化为它们的默认值。 b.结构不能包含以下形式的初始值设定类：base（argument-list）； 2.对于结构中的实例字段成员，不能在声明时赋值初始化。 3.声明了结构类型后，可以使用new运算符创建构造对象，也可以不使用new关键字。如果不使用new，那么在初始化所有字段之前，字段将保持未赋值状态且对象不可用。 4.结构不支持继承，即一个结构不能从另一个结构或类继承，而且不能作为一个类的基类。但是，结构从基类OBJECT继承。结构也可以实现接口。 5.什么时候用结构呢？结构使用简单，并且很有用，但是要牢记：结构在堆栈中创建，是值类型，而类是引用类型。每当需要一种经常使用的类型，而且大多数情况下该类型只是一些数据时，使用结构能比使用类获得更佳性能。 最后引用博客园的“越过林子”的话： 结构是值类型，所以会影响性能，但根据使用结构的方式，这种影响可能是正面的，也可能是负面的。正面的影响是为结构分配内存时，速度非常快，因为它们将内联或者保存在堆栈中。在结构超出了作用域被删除时，速度也很快。另一方面，只要把结构作为参数来传递或者把一个结构赋给另一个结构(例如A=B，其中A和B是结构)，结构的所有内容就被复制，而对于类，则只复制引用。这样，就会有性能损失，根据结构的大小，性能损失也不同。注意，结构主要用于小的数据结构。但当把结构作为参数传递给方法时，就应把它作为ref参数传递，以避免性能损失——此时只传递了结构在内存中的地址，这样传递速度就与在类中的传递速度一样快了。另一方面，如果这样做，就必须注意被调用的方法可以改变结构的值。 C#中结构与类的区别 作者:未知时间:2004-10-20 12:12 出处:互联网责编:jizhuwo 摘要：暂无 本文目录 类与结构的实例比较 类与结构的差别 c语言中struct的用法 c语言中struct的用法的用法如下：基本定义：结构体，通俗讲就像是打包封装，把一些有共同特征（比如同属于某一类事物的属性，往往是某种业务相关属性的聚合）的变量封装在内部，通过一定方法访问修改内部变量。 结构体定义：第一种：只有结构体定义[cpp] view plain copy 在CODE上查看代码片派生到我的代码片01.struct stuff{02. char job[20];03. int age;04. float height;05.};第二种：附加该结构体类型的“结构体变量的初始化的结构体定义[cpp] view plain copy 在CODE 上查看代码片派生到我的代码片01.//直接带变量名Huqinwei02.struct stuff{03. char job[20];04. int age;05. float height;06.}Huqinwei;也许初期看不习惯容易困惑，其实这就相当于：[cpp] view plain copy 在CODE上查看代码片派生到我的代码片01.struct stuff{02. char job[20];03. int age;04. float height;05.};06.struct stuff Huqinwei;第三种：如果该结构体你只用一个变量Huqinwei，而不再需要用[cpp] view plain copy 在CODE上查看代码片派生到我的代码片01.struct stuff yourname;去定义第二个变量。 结构体变量及其内部成员变量的定义及访问：绕口吧？要分清结构体变量和结构体内部成员变量的概念。 就像刚才的第二种提到的，结构体变量的声明可以用：[cpp] view plain copy 在CODE上查看代码片派生到我的代码片01.struct stuff (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) 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 7．定义以下结构体类型 struct student { char name[10]; int score[50]; float average; }stud1; 则stud1占用内存的字节数是【】。 A) 64 B) 114 C) 228 D) 7 9、设有一结构体类型变量定义如下： struct date { int year; int month; int day; }; struct worklist { char name[20]; char sex; struct date birthday; } person; 若对结构体变量person的出生年份进行赋值时，下面正确的赋值语句是。。。。 A. year=1976 B. =1976 C. D. =1976 1、若程序中有以下的说明和定义： struct abc { int x;char y; } 花括号后少了分号。 struct abc s1,s2; 则会发生的情况是______。 A) 编译时错B) 程序将顺序编译、连接、执行C) 能顺序通过编译、连接、但不能执行D) 能顺序通过编译、但连接出错 结构体在函数中的应用 前天在编写一段代码时突然对结构体在函数中的用法有些模糊了，经过复习，基本弄清了这些知识，特总结如下： 一、结构体与函数参数 结构体作函数参数可分为传值与传指针。 1．传值时结构体参数会被拷贝一份，在函数体内修改结构体参数成员的值实际上是修改调用参数的一个临时拷贝的成员的值，这不会影响到调用参数。在这种情况下，由于涉及到结构体参数的拷贝，程序空间及时间效率都会受到影响，所以这种方法基本不用。 例如： 2．传指针时直接将结构体的首地址传递给函数体，在函数体中通过指针引用结构体成员，可以对结构体参数成员的值造成实际影响。这种用法效率高，经常采用。 例如： 二、结构体与函数返回值 对于某些版本的C语言编译器，返回值仅能为基本数据类型如int、char以及指针，因此结构体作为一种组合数据类型，不能以值的方式返回，而在有些版本的C编译器中又可以直接返回结构体变量，在C++中也是可以直接返回结构体变量的。 直接返回结构体变量示例如下； 以指针方式返回结构体示例如下： 关于结构体，看内核又遇到了，关于赋值中存在·的奇怪用法，在网上没有找到答案，却把以前一直弄的比较模糊的对齐问题给翻出来了。如下为转发内容： 齐原则总结：（在没有#pragma pack宏的情况下）： 原则1：数据成员对齐规则：结构（struct或联合union）的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小的整数倍开始（比如int在32位机为４字节，则要从4的整数倍地址开始存储）。 原则2：结构体作为成员：如果一个结构里有某些结构体成员，则结构体成员要从其内部 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的语句是【】。 第九章结构体类型与公用体类型习题及其答案9-3编写程序，使用结构体类型，输出一年十二个月的英文名称及相应天数。 解：#include "stdio.h" struct date { char month[10] ; int daynumber ; } main() { int i ; date a[12] ={{"January",31},{"February",29},{"March",31},{"Aprial",30}, {"May",31},{"June",30},{"july",31},{"August",31},{"September",30} ,{"October",31},{"November",30},{"December",31}} ; for(i=0;i<12;i++); printf("%d 月:%s %d\n",i+1,a[i].month,a[i].daynumber) ; } 思考：如何对结构体变量进行初始化？对结构体变量的引用为何要体现为分量（或成员）的引用？ 9-4 编写程序求空间任一点到原点的距离，点用结构体描述。并请考虑求空间中任意两点的距离的程序。 解：#include "stdio.h" #include "math.h" struct point { float x ; float y ; float z ; } void main() { double d1,d2,d ; point p1,p2 ; printf("请输入第一个点的坐标："); scanf("%f,%f,%f",&p1.x,&p1.y,&p1.z); printf("请输入第二个点的坐标："); scanf("%f,%f,%f",&p2.x,&p2.y,&p2.z); d1=sqrt(p1.x*p1.x+p1.y*p1.y+p1.z*p1.z); d2=sqrt(p2.x*p2.x+p2.y*p2.y+p2.z*p2.z); d=sqrt((p2.x-p1.x)*(p2.x-p1.x)+(p2.y-p1.y)*(p2.y-p1.y)+(p2.z-p1.z)*( p2.z-p1.z)); printf("第一个点到原点的距离：%f\n",d1); printf("第二个点到原点的距离：%f\n",d2); printf("两点间的距离：%f\n",d); } 9-5 编写输入、输出10个朋友数据的通讯录程序，每个朋友数据包括姓名、地址、邮编、电话、传呼、手机等数据。 解：#include "stdio.h" struct AddressBook { char name[10] ; char address[30] ; char mailnumber[7] ; char telphone[12] ; char byphone[16] ; char movephone[1] ; } void main() { int i ; AddressBook fd[10] ; for(i=0;i<10;i++) { printf("请输入第%d个朋友的信息：\n",i+1); printf("姓名：");结构体的使用方法
结构体练习题
结构体和类的比较
类和结构体的区别
C语言结构体习题及答案
结构体的指针应用
C语言中不同的结构体类型的指针间的强制转换详解
c语言结构体用法(转载)
类与结构体的区别
结构体的定义及初始化
(完整版)matlab中使用结构体汇总
第九章使用结构体类型处理组合数据 c语言
类与结构体的区别
C语言结构体(struct)常见使用方法
c#中结构体和类的比较
c语言中struct的用法
(1)定义结构体的关键字是
C语言结构体习题及答案
结构体在函数中的应用
C语言结构体习题及答案知识讲解
第9章结构体类型与共用体类型习题及答案
相关主题
文本预览