现在，结构体来救你了(e文：the struct comes to rescue)。看看如何用结构体定义一个拳皇人物吧。
在学习结构体之前，你会很自然的想到使用如下的变量来描述：
name, height, weight, strong, modfile。
好了，现在来给Kula和K分别进行描述，你就需要在变量名上加以区分。对于Kula你有了
Kula_name, Kula_height, Kula_weight, Kula_strong, Kula_modfile
对于K，你有了
K_name, K_height, K_weight, K_strong, K_modfile
好，设想你现在要制作KOF2003了，我们需要一个函数根据这些信息在战斗中评价两位选手，这个函数看上去像是这样
int value(char *name, int height, int weight, int strong, char *modfile);
当然在实际测试中一个人物的信息可能不止这几个，也许他有30个之多，我相信你是不会写一个有30个参数的函数的（除非你为Microsoft工作）。更糟糕的是，如果由于版本更新发现30个参数里有15个是多余的，在修改了函数定义之后，你还要修改无数的不只位置函数调用。汗！
现在，结构体来救你了(e文：the struct comes to rescue)。看看如何用结构体定义一个拳皇人物吧。首先我们定义一个结构体类型：
struct FIGHTER {
char *name; /*元素1*/
int height; /*元素2*/
int weight; /*元素3*/
int strong; /*元素4*/
char *modfile; /*元素5*/
};
这个类型叫FIGHTER，他和你用的int在语法上是一样，他们都是类型。正如你使用int声明变量一样，你可以用FIGHTER声明变量。FIGHTER有一些比int特殊的地方，他是结构体。所以声明变量时，你给跟TC提这件事(在FIGHTER前加上struct关键词)。声明变量的方法如下：
struct FIGHTER Kula, K, Iori, Athena;
好了，你定义了很多FIGHTER变量。那么如何使用他们呢。对于设置一个人物我们可以这样：
Kula.height = 1.65;
Kula.weight = 49;
Kula.strong = 75;
这里，height，weight，strong是Kula内的元素。这就好像同一规格的不同书包一样。Kula是这种规格书包的一种，而height，weight，strong就是书包里袋子的名称。自然书包K里height袋子和书包Kula里height袋子是两个完全独立的袋子，他们互不干扰。
你注意到了Kula和height之间有一个点，专业一点的称呼叫 成员运算符(member operator)。当然我还是叫她"点"。
现在回到value函数的问题，我们不再需要那么多参数了。我们只要
int value(struct FIGHTER fighter);
这样，在评价Kula的时候我们使用的是value(Kula)而不是什么value(Kula_height, Kula_weight, ......, 汗！);
一定会发现结构对于描述一样带有很多属性的东西有天生的优越性。比如
struct POINT {
int x;
int y;
};
struct RECT {
int left;
int top;
int bottom;
int right;
};
.....
使用结构体编程可以让你尽快熟悉OOP(面向对象程序设计)。
不过，...嘻嘻，你没觉得每次在声明结构体时的语法中有个struct在前面很不爽
struct RECT rt;
我想让他像声明int型一样简单，打个RECT rt就行了那多好。于是你就打了一个
RECT rt;
然后编译器给了一个惊人的回答：
Declaration syntax error 定义语法错误。
希望没有破灭！现在，typedef comes to rescue(c文：typedef来帮忙了)
记得我们可以用typedef定义类型别名吧，比如unsigned int太长了，不好打，我们用
typedef unsigned int UINT;
来定义和unsigned int的同义词UINT，这样一来unsigned int a 和 UINT a就是一回事了。现在来看看这个语法结构。
typedef struct POINT PT;
呵呵，看到了吧PT和struct POINT 这么长的一个东西成了同义词了。以后直接用PT就可以了比如struct POINT point就可以用PT point代替了，爽吧！
其实，还有更爽的，我们把typedef和struct定义结合在一起。
typedefstruct POINT {
int x;
int y;
} PT;
更简单！这种做法是很多程序里惯用的。当然，我们用更好的方法给变量命名，国际上一般采用这样的命名方法
typedef struct tagPOINT {
int x;
int y;
} POINT;
这样我们就可以直接用 POINT pt1, pt2；定义POINT型的变量了。呵呵看起来是不是和int的语法一样了。
一、结构体入门——定义与成员
1. 结构定义
在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 Tianyr, Liuqi, ...;
如果省略结构名，则称之为无名结构，这种情况常常出现在函数内部，用这种结构时前面的例子变成：
struct
{
char name[8];
int age;
char sex[2];
char depart[20];
float wage1, wage2, wage3, wage4, wage5;
} Tianyr, Liuqi;
2. 结构成员
结构是一个新的数据类型，因此结构变量也可以象其它类型的变量一样赋值、运算，不同的是结构变量以成员作为基本变量。
结构成员的表示方式为：
结构变量.成员名
如果将"结构变量.成员名"看成一个整体，则这个整体的数据类型与结构中该成员的数据类型相同，这样就可象前面所讲的变量那样使用。
下面这个例子定义了一个结构变量，其中每个成员都从键盘接收数据，然后对结构中的浮点数求和，并显示运算结果，同时将数据以文本方式存入一个名为wage.dat的磁盘文件中。请注意这个例子中不同结构成员的访问。
例1：
#include <stdio.h>
main()
{
struct{ /*定义一个结构变量*/
char name[8];
int age;
char sex[2];
char depart[20];
float wage1, wage2, wage3, wage4, wage5;
}a;
FILE *fp;
float wage;
char c='Y';
fp=fopen("wage.dat", "w"); /*创建一个文件只写*/
while(c=='Y'||c=='y') /*判断是否继续循环*/
{
printf("nName:");
scanf("%s", a.name); /*输入姓名*/
printf("Age:");
scanf("%d", &a.wage); /*输入年龄*/
printf("Sex:");
scanf("%d", a.sex);
printf("Dept:");
scanf("%s", a.depart);
printf("Wage1:");
scanf("%f", &a.wage1); /*输入工资*/
printf("Wage2:");
scanf("%f", &a.wage2);
printf("Wage3:");
scanf("%f", &a.wage3);
printf("Wage4:");
scanf("%f", &a.wage4);
printf("Wage5:");
scanf("%f", &a.wage5);
wage=a.wage1+a.wage2+a.wage3+a.wage4+a.wage5;
printf("The sum of wage is %<?xml:namespace prefix = st1 ns = "urn:schemas-microsoft-comffice:smarttags" />6.2fn", wage);/*显示结果*/
fprintf(fp, "%10s%4d%4s%30s%10.2fn", /*结果写入文件*/
a.name, a.age, a.sex, a.depart, wage);
while(1)
{
printf("Continue?<Y/N>");
c=getche();
if(c=='Y'||c=='y'||c=='N'||c=='n')
break;
}
}
fclose(fp);
}
二、结构体进阶——数组与指针
结构是一种新的数据类型，同样可以有结构数组和结构指针。
1. 结构数组
结构数组就是具有相同结构类型的变量集合。假如要定义一个班级40个同学的姓名、性别、年龄和住址，可以定义成一个结构数组。如下所示：
struct{
char name[8];
char sex[2];
int age;
char addr[40];
}student[40];
也可定义为：
struct string{
char name[8];
char sex[2];
int age;
char addr[40];
};
struct string student[40];
需要指出的是结构数组成员的访问是以数组元素为结构变量的，其形式为：
结构数组元素.成员名
例如：
student[0].name
student[30].age
实际上结构数组相当于一个二维构造，第一维是结构数组元素，每个元素是一个结构变量，第二维是结构成员。
注意：
结构数组的成员也可以是数组变量。
例如：
struct a
{
int m[3][5];
float f;
char s[20];
}y[4];
为了访问结构a中结构变量y[2]的这个变量，可写成
y[2].m[1][4]
2. 结构指针
结构指针是指向结构的指针。它由一个加在结构变量名前的"*"操作符来定义，例如用前面已说明的结构定义一个结构指针如下：
struct string{
char name[8];
char sex[2];
int age;
char addr[40];
}*student;
也可省略结构指针名只作结构说明，然后再用下面的语句定义结构指针。
struct string *student;
使用结构指针对结构成员的访问，与结构变量对结构成员的访问在表达方式上有所不同。结构指针对结构成员的访问表示为：
结构指针名->结构成员
其中"->"是两个符号"-"和">"的组合，好象一个箭头指向结构成员。例如要给上面定义的结构中name和age赋值，可以用下面语句：
strcpy(student->name, "Lu G.C");
student->age=18;
实际上，student->name就是(*student).name的缩写形式。
需要指出的是结构指针是指向结构的一个指针，即结构中第一个成员的首地址，因此在使用之前应该对结构指针初始化，即分配整个结构长度的字节空间，这可用下面函数完成，仍以上例来说明如下：
student=(struct string*)malloc(size of (struct string));
size of (struct string)自动求取string结构的字节长度，malloc()函数定义了一个大小为结构长度的内存区域，然后将其诈地址作为结构指针返回。
注意：
1. 结构作为一种数据类型，因此定义的结构变量或结构指针变量同样有局部变量和全程变量，视定义的位置而定。
2. 结构变量名不是指向该结构的地址，这与数组名的含义不同，因此若需要求结构中第一个成员的首地址应该是&[结构变量名]。
三、结构体提高——嵌套与位结构
1. 嵌套结构
嵌套结构是指在一个结构成员中可以包括其它一个结构，C 允许这种嵌套。
例如：下面是一个有嵌套的结构
struct string{
char name[8];
int age;
struct addr address;
} student;
其中：addr为另一个结构的结构名，必须要先进行说明，即
struct addr{
char city[20];
unsigned lon zipcode;
char tel[14];
}
如果要给student结构中成员address结构中的zipcode赋值，则可写成：
student.address.zipcode=200001;
每个结构成员名从最外层直到最内层逐个被列出，即嵌套式结构成员的表达方式是：
结构变量名.嵌套结构变量名.结构成员名
其中：嵌套结构可以有很多，结构成员名为最内层结构中不是结构的成员名。
2. 位结构
位结构是一种特殊的结构，在需按位访问一个字节或字的多个位时，位结构比按位运算符更加方便。
位结构定义的一般形式为：
struct位结构名{
数据类型变量名: 整型常数;
数据类型变量名: 整型常数;
} 位结构变量;
其中：数据类型必须是int(unsigned或signed)。整型常数必须是非负的整数，范围是0~15，表示二进制位的个数，即表示有多少位。
变量名是选择项，可以不命名，这样规定是为了排列需要。
例如：下面定义了一个位结构。
struct{
unsigned incon: 8; /*incon占用低字节的0~7共8位*/
unsigned txcolor: 4;/*txcolor占用高字节的0~3位共4位*/
unsigned bgcolor: 3;/*bgcolor占用高字节的4~6位共3位*/
unsigned blink: 1; /*blink占用高字节的第7位*/
}ch;
位结构成员的访问与结构成员的访问相同。
例如：访问上例位结构中的bgcolor成员可写成：
ch.bgcolor
注意：
1. 位结构中的成员可以定义为unsigned，也可定义为signed，但当成员长度为1时，会被认为是unsigned类型。因为单个位不可能具有符号。
2. 位结构中的成员不能使用数组和指针，但位结构变量可以是数组和指针，如果是指针，其成员访问方式同结构指针。
3. 位结构总长度(位数)，是各个位成员定义的位数之和，可以超过两个字节。
4. 位结构成员可以与其它结构成员一起使用。
例如：
struct info{
char name[8];
int age;
struct addr address;
float pay;
unsigned state: 1;
unsigned pay: 1;
}workers;
上例的结构定义了关于一个工从的信息。其中有两个位结构成员，每个位结构成员只有一位，因此只占一个字节但保存了两个信息，该字节中第一位表示工人的状态，第二位表示工资是否已发放。由此可见使用位结构可以节省存贮空间。
四、结构体扩展——联合体
联合也是一种新的数据类型，它是一种特殊形式的变量。
联合说明和联合变量定义与结构十分相似。其形式为：
union 联合名{
数据类型成员名;
数据类型成员名;
...
} 联合变量名;
联合表示几个变量公用一个内存位置，在不同的时间保存不同的数据类型和不同长度的变量。
下例表示说明一个联合a_bc：
union a_bc{
int i;
char mm;
};
再用已说明的联合可定义联合变量。
例如用上面说明的联合定义一个名为lgc的联合变量，可写成：
union a_bc lgc;
在联合变量lgc中，整型量i和字符mm公用同一内存位置。
当一个联合被说明时，编译程序自动地产生一个变量，其长度为联合中最大的变量长度。
联合访问其成员的方法与结构相同。同样联合变量也可以定义成数组或指针，但定义为指针时，也要用"->"符号，此时联合访问成员可表示成：
联合名->成员名
另外，联合既可以出现在结构内，它的成员也可以是结构。
例如：
struct{
int age;
char *addr;
union{
int i;
char *ch;
}x;
}y[10];
若要访问结构变量y[1]中联合x的成员i，可以写成：
y[1].x.i;
若要访问结构变量y[2]中联合x的字符串指针ch的第一个字符可写成：
*y[2].x.ch;
若写成"y[2].x.*ch;"是错误的。
结构和联合有下列区别：
1. 结构和联合都是由多个不同的数据类型成员组成，但在任何同一时刻，联合中只存放了一个被选中的成员，而结构的所有成员都存在。
2. 对于联合的不同成员赋值，将会对其它成员重写，原来成员的值就不存在了，而对于结构的不同成员赋值是互不影响的。
下面举一个例了来加对深联合的理解。
例2：
main()
{
union{ /*定义一个联合*/
int i;
struct{ /*在联合中定义一个结构*/
char first;
char second;
}half;
}number;
number.i=0x4241; /*联合成员赋值*/
printf("%c%cn", number.half.first, mumber.half.second);
number.half.first='a'; /*联合中结构成员赋值*/
number.half.second='b';
printf("%xn", number.i);
getch();
}
输出结果为:
AB
6261
从上例结果可以看出：当给i赋值后，其低八位也就是first和second的值；当给first和second赋字符后，这两个字符的ASCII码也将作为i的低八位和高八位。
有了以上的基础，下面的内容（按C++语法写的）就比较好消化吸收了！！
C/C++中的结构体
什么是结构体？
简单的来说，结构体就是一个可以包含不同数据类型的一个结构，它是一种可以自己定义的数据类型，它的特点和数组主要有两点不同，首先结构体可以在一个结构中声明不同的数据类型，第二相同结构的结构体变量是可以相互赋值的，而数组是做不到的，因为数组是单一数据类型的数据集合，它本身不是数据类型(而结构体是)，数组名称是常量指针，所以不可以做为左值进行运算，所以数组之间就不能通过数组名称相互复制了，即使数据类型和数组大小完全相同。
定义结构体使用struct修饰符，例如：
struct test
{
float a;
int b;
};
上面的代码就定义了一个名为test的结构体，它的数据类型就是test，它包含两个成员a和b，成员a的数据类型为浮点型，成员b的数据类型为整型。
由于结构体本身就是自定义的数据类型，定义结构体变量的方法和定义普通变量的方法一样。
test pn1;
这样就定义了一test结构体数据类型的结构体变量pn1，结构体成员的访问通过点操作符进行，pn1.a=10就对结构体变量pn1的成员a进行了赋值操作。
注意：结构体生命的时候本身不占用任何内存空间，只有当你用你定义的结构体类型定义结构体变量的时候计算机才会分配内存。
结构体，同样是可以定义指针的，那么结构体指针就叫做结构指针。
结构指针通过->符号来访问成员，下面我们就以上所说的看一个完整的例子：
#include<iostream>
#include<string>
usingnamespacestd;
structtest//定义一个名为test的结构体
{
inta;//定义结构体成员a
intb;//定义结构体成员b
};
voidmain()
{
testpn1;//定义结构体变量pn1
testpn2;//定义结构体变量pn2
pn2.a=10;//通过成员操作符.给结构体变量pn2中的成员a赋值
pn2.b=3;//通过成员操作符.给结构体变量pn2中的成员b赋值
pn1=pn2;//把pn2中所有的成员值复制给具有相同结构的结构体变量pn1
cout<<pn1.a<<"|"<<pn1.b<<endl;
cout<<pn2.a<<"|"<<pn2.b<<endl;
test*point;//定义结构指针
point=&pn2;//指针指向结构体变量pn2的内存地址
cout<<pn2.a<<"|"<<pn2.b<<endl;
point->a=99;//通过结构指针修改结构体变量pn2成员a的值
cout<<pn2.a<<"|"<<pn2.b<<endl;
cout<<point->a<<"|"<<point->b<<endl;
cin.get();
}
总之，结构体可以描述数组不能够清晰描述的结构，它具有数组所不具备的一些功能特性。
下面我们来看一下，结构体变量是如何作为函数参数进行传递的。
#include<iostream>
#include<string>
usingnamespacestd;
structtest
{
charname[10];
floatsocre;
};
voidprint_score(testpn)//以结构变量进行传递
{
cout<<pn.name<<"|"<<pn.socre<<endl;
}
voidprint_score(test*pn)//一结构指针作为形参
{
cout<<pn->name<<"|"<<pn->socre<<endl;
}
voidmain()
{
testa[2]={{"marry",88.5},{"jarck",98.5}};
intnum=sizeof(a)/sizeof(test);
for(inti=0; i<num; i++)
{
print_score(a[i]);
}
for(inti=0; i<num; i++)
{
print_score(&a[i]);
}
cin.get();
}
void print_score(test *pn)的效率是要高过void print_score(test pn)的，因为直接内存操作避免了栈空间开辟结构变量空间需求，节省内存。
下面我们再说一下，传递结构引用的例子。
利用引用传递的好处很多，它的效率和指针相差无几，但引用的操作方式和值传递几乎一样，种种优势都说明善用引用可以做到程序的易读和易操作，它的优势尤其在结构很大的时候，避免传递结构变量很大的值，节省内存，提高效率。
#include<iostream>
#include<string>
usingnamespacestd;
structtest
{
charname[10];
floatsocre;
};
voidprint_score(test&pn)//以结构变量进行传递
{
cout<<pn.name<<"|"<<pn.socre<<endl;
}
voidmain()
{
testa[2]={{"marry",88.5},{"jarck",98.5}};
intnum=sizeof(a)/sizeof(test);
for(inti=0;i<num;i++)
{
print_score(a[i]);
}
cin.get();
}
上面我们说明了易用引用对结构体进行操作的优势，下面我们重点对比两个例程，进一部分析关于效率的问题。
//-------------------------------------例程1---------------------------------
#include<iostream>
#include<string>
usingnamespacestd;
structtest
{
charname[10];
floatsocre;
};
voidprint_score(test&pn)
{
cout<<pn.name<<"|"<<pn.socre<<endl;
}
testget_score()
{
testpn;
cin>>pn.name>>pn.socre;
returnpn;
}
voidmain()
{
testa[2];
intnum=sizeof(a)/sizeof(test);
for(inti=0;i<num;i++)
{
a[i]=get_score();
}
cin.get();
for(inti=0;i<num;i++)
{
print_score(a[i]);
}
cin.get();
}
//-------------------------------------例程2---------------------------------
#include<iostream>
#include<string>
usingnamespacestd;
structtest
{
charname[10];
floatsocre;
};
voidprint_score(test&pn)
{
cout<<pn.name<<"|"<<pn.socre<<endl;
}
voidget_score(test&pn)
{
cin>>pn.name>>pn.socre;
}
voidmain()
{
testa[2];
intnum=sizeof(a)/sizeof(test);
for(inti=0;i<num;i++)
{
get_score(a[i]);
}
cin.get();
for(inti=0;i<num;i++)
{
print_score(a[i]);
}
cin.get();
}
例程2的效率要远高过例程1的原因主要有以下两处：
第一：例程1中的
test get_score()
{
test pn;
cin>>pn.name>>pn.socre;
return pn;
}
调用的时候在内部要在栈空间开辟一个名为pn的结构体变量，程序pn的时候又再次在栈内存空间内自动生成了一个临时结构体变量temp，在前面的教程中我们已经说过，它是一个copy，而例程2中的：
void get_score(test &pn)
{
cin>>pn.name>>pn.socre;
}
却没有这一过程，不开辟任何新的内存空间，也没有任何临时变量的生成。
第二：例程1在mian()中，必须对返回的结构体变量进行一次结构体变量与结构体变量直接的相互赋值操作。
for(int i=0;i<num;i++)
{
a[i]=get_score();
}
而例程2中由于是通过内存地址直接操作，所以完全没有这一过程，提高了效率。
for(int i=0;i<num;i++)
{
get_score(a[i]);
}
函数也是可以返回结构体应用的，例子如下：
#include<iostream>
#include<string>
usingnamespacestd;
structtest
{
charname[10];
floatsocre;
};
testa;
test&get_score(test&pn)
{
cin>>pn.name>>pn.socre;
returnpn;
}
voidprint_score(test&pn)
{
cout<<pn.name<<"|"<<pn.socre<<endl;
}
voidmain()
{
test&sp=get_score(a);
cin.get();
cout<<sp.name<<"|"<<sp.socre;
cin.get();
}
调用get_score(a);结束并返回的时候，函数内部没有临时变量的产生，返回直接吧全局结构变量a的内存地址赋予结构引用sp
最后提一下指针的引用
定义指针的引用方法如下：
voidmain()
{
inta=0;
intb=10;
int*p1=&a;
int*p2=&b;
int*&pn=p1;
cout<<pn<<"|"<<*pn<<endl;
pn=p2;
cout<<pn<<"|"<<*pn<<endl;
cin.get();
}
pn就是一个指向指针的引用，它也可以看做是指针别名，总之使用引用要特别注意它的特性，它的操作是和普通指针一样的，在函数中对全局指针的引用操作要十分小心，避免破坏全局指针！