读书笔记摘抄新闻资讯
结构体类型
C++提供了许多种基本的数据类型（如int、float、double、char等）供用户使用。但是由于程式需要处理的问题往往比较複杂，而且呈多样化，已有的数据类型显得不能满足使用要求。因此C++允许用户根据需要自己声明一些类型，用户可以自己声明的类型还有结构体类型(structure)、共用体类型(union)、枚举类型(enumeration)、类类型(class )等，这些统称为用户自定义类型(user-defined type,UDT)。
基本介绍
- 中文名：结构体类型
- 外文名：struct Node
概述
在C语言中，结构体(struct)指的是一种数据结构，是C语言中聚合数据类型(aggregate data type)的一类。结构体可以被声明为变数、指针或数组等，用以实现较複杂的数据结构。结构体同时也是一些元素的集合，这些元素称为结构体的成员(member)，且这些成员可以为不同的类型，成员一般用名字访问。
C++提供了许多种基本的数据类型(如int、float、double、char等)供用户使用。但是由于程式需要处理的问题往往比较複杂，而且呈多样化，已有的数据类型显得不能满足使用要求。因此C++允许用户根据需要自己声明一些类型,用户可以自己声明的类型还有结构体类型(structure)、共用体类型(union)、枚举类型(enumeration)、类类型(class )等，这些统称为用户自定义类型(user-defined type,UDT)。
在一个组合项中包含若干个类型不同（当然也可以相同）的数据项。C和C++允许用户自己指定这样一种数据类型，它称为结构体。它相当于其他高级语言中的记录(record)。例如，可以通过下面的声明来建立数据类型。
struct Student//声明一个结构体类型Student
{
int num;//包括一个整型变数num
char name[20];//包括一个字元数组name，可以容纳20个字元
char sex;//包括一个字元变数sex
int age;//包括一个整型变数age
float score;//包括一个单精度型变数
char addr[30];//包括一个字元数组addr，可以容纳30个字元
};//最后有一个分号
这样，程式设计者就声明了一个新的结构体类型Student(struct是声明结构体类型时所必须使用的关键字，不能省略)，它向编译系统声明： 这是一种结构体类型，它包括num, name, sex, age, score, addr等不同类型的数据项。应当说明Student是一个类型名，它和系统提供的标準类型（如int、char、float、double 一样，都可以用来定义变数，只不过结构体类型需要事先由用户自己声明而已。
声明一个结构体类型的一般形式为
struct 结构体类型名{成员表列}；
结构体类型名用来作结构体类型的标誌。上面的声明中Student就是结构体类型名。大括弧内是该结构体中的全部成员(member)，由它们组成一个特定的结构体。上例中的num,name,sex,score等都是结构体中的成员。在声明一个结构体类型时必须对各成员都进行类型声明即类型名成员名；每一个成员也称为结构体中的一个域(field)。成员表列又称为域表。
成员名的定名规则与变数名的定名规则相同
声明结构体类型的位置一般在档案的开头，在所有函式(包括main函式)之前，以便本档案中所有的函式都能利用它来定义变数。当然也可以在函式中声明结构体类型。
在C语言中，结构体的成员只能是数据(如上面例子中所表示的那样)。
C++对此加以扩充，结构体的成员既可以包括数据(即数据成员)，又可以包括函式(即函式成员)，以适应面向对象的程式设计。
定义
前面只是指定了一种结构体类型，它相当于一个模型，但其中并无具体数据，系统也不为之分配实际的记忆体单元为了能在程式中使用结构体类型的数据，应当定义结构体类型的变数，并在其中存放具体的数据。
定义
(1） 先声明结构体类型再定义变数名如上面已定义了一个结构体类型Student，可以用它来定义结构体变数。如
struct Student student1, student2；
以上定义了student1和student2为结构体类型struct Student的变数，即它们具有struct Student类型的结构。在定义了结构体变数后，系统会为之分配记忆体单元。例如student1和student2在记忆体中各占63个位元组
（4+20+1+4+4+30=63）。
但是这里需要注意：名义上计算大小为63，根据不同编译器，记忆体存储会有所不同，在存储该结构体时会按照记忆体对齐进行相关处理，系统默认对齐係数为4（即按int类型对齐，粗略认识可以认为每相邻两个数据成员存储是大小是4的整数倍，请参考下面对比结构体），详情请参考记忆体对齐，因此该结构体实际大小为：68，具体计算如下：
{
int num;//整型，4个位元组
char name[20];//字元数组20个位元组，4的整数倍，取20位元组
char sex;//字元类型，一个位元组，往下不能凑齐4个位元组，因此取4个位元组
int age;//以下同理 4个位元组
float score;//4个位元组
char addr[30];//字元数组30个位元组，取4整数倍，因此为32
}
故实际大小为：4+20+4+4+4+32=68
对比结构体：1
{
int num;//整型，4个位元组
char name[19];//字元数组19个位元组，往下能取4的整数倍，取20位元组
char sex;//存放在上面字元数组char name[19]后面，凑成20位元组，为了表示存在这个数据，在这里给个0
int age;//以下同理 4个位元组
float score;//4个位元组
char addr[30];//字元数组30个位元组，取4整数倍，因此为32
}
故实际大小为：4+20+0+4+4+32=64
对比结构体：2{
int num;//整型，4个位元组
char name[20];//字元数组19个位元组，往下能取4的整数倍，取20位元组
char sex;//字元类型，一个位元组，往下能凑上一个字元数据位元组，单任不能凑齐4个位元组，因此取4个位元组
char test;//新增加的数据类型，已往上存放，为了表示存在这个数据，这里给个0
int age;//以下同理 4个位元组
float score;//4个位元组
char addr[30];//字元数组30个位元组，取4整数倍，因此为32
}
故实际大小为：4+20+4+0+4+4+32=68
(2) 在声明类型的同时定义变数
例如：
struct Student//声明结构体类型Student
{
int num;
char name[20];
char sex;
int age;
float score;
char addr[30];
}student1,student2;//定义两个结构体类型Student的变数student1,student2
这种形式的定义的一般形式为
struct 结构体名
{
成员表列
}变数名表列；
(3) 直接定义结构体类型变数
其一般形式为
struct//注意没有结构体类型名
{
成员表列
} 变数名表列；
这种方法虽然合法，但很少使用。提倡先定义类型后定义变数的第(1)种方法。
在程式比较简单，结构体类型只在本档案中使用的情况下，也可以用第(2)种方法。
关于结构体类型，有几点要说明：
(1) 不要误认为凡是结构体类型都有相同的结构。实际上，每一种结构体类型都有自己的结构，可以定义出许多种具体的结构体类型。
(2) 类型与变数是不同的概念，不要混淆。只能对结构体变数中的成员赋值，而不能对结构体类型赋值。在编译时，是不会为类型分配空间的，只为变数分配空间。
(3) 对结构体中的成员（即“域”），可以单独使用，它的作用与地位相当于普通变数。
(4) 成员也可以是一个结构体变数。
如
struct Date //声明一个结构体类型Date
{
int month;
int day;
int year;
};
struct Student
//声明一个结构体类型Student
{
int num;
char name[20];
char sex;
int age;
Date birthday;
char addr[30];
}student1,student2;
//定义student1和student2为结构体类型Student的变数Student的结构。
(5) 结构体中的成员名可以与程式中的变数名相同,但二者没有关係。
例如,程式中可以另定义一个整型变数num,它与student中的num是两回事,互不影响。
初始化
和其他类型变数一样，对结构体变数可以在定义时指定初始值。如
struct Student
{
int num;
char name[20];
char sex;
int age;
float score;
char addr[30];
}student1={10001,"Zhang Xin",'M',19,90.5,"Shanghai"};
这样，变数student1中的数据如图7.2中所示。也可以採取声明类型与定义变数分开的形式，在定义变数时进行初始化：
student2= student1;
变数
在定义了结构体变数以后,当然可以引用这个变数。
(1) 可以将一个结构体变数的值赋给另一个具有相同结构的结构体变数。
如上面的student1和student2都是student类型的变数，可以这样赋值：
student1= student2;
(2) 可以引用一个结构体变数中的一个成员的值。
例如， student1.num表示结构体变数student1中的成员的值，如果student1的值如图7.2所示，
则student1.num的值为10001。
引用结构体变数中成员的一般方式为
结构体变数名.成员名
例如可以这样对变数的成员赋值:
student1.num=10010;
(3) 如果成员本身也是一个结构体类型,则要用若干个成员运算符,一级一级地找到最低一级的成员。
例如,对上面定义的结构体变数student1, 可以这样访问各成员:
student1.num (引用结构体变数student1中的num成员)
如果想引用student1变数中的birthday成员中的month成员，不能写成student1.month，
必须逐级引用，即
student1.birthday.month=12;
(引用结构体变数student1中的birthday成员中的month成员)
(4) 不能将一个结构体变数作为一个整体进行输入和输出。
例如,已定义student1和student2为结构体变数,并且它们已有值。不能企图这样输出结构体变数中的各成员的值:
cin>>student1;
只能对结构体变数中的各个成员分别进行输入和输出。
(5) 对结构体变数的成员可以像普通变数一样进行各种运算（根据其类型决定可以进行的运算种类）。例如
student2.score=student1.score；
sum=student1.score+student2.score；
student1.age++；
++student1.age；
由于“.”运算符的优先权最高，student1.age++相当于(student1.age)++ 。++是对student1.age进行自加运算，而不是先对age进行自加运算。
(6) 可以引用结构体变数成员的地址，也可以引用结构体变数的地址。如
cout<<&student1;//输出student1的首地址
cout<<&student1.age;//输出student1.age的地址
结构体变数的地址主要用作函式参数，将结构体变数的地址传递给形参。
例 引用结构体变数中的成员。
#include <iostream>
using namespace std;
struct Date//声明结构体类型Date
{int month;
int day;
int year;
};
{int num;
char sex;
Date birthday;//声明birthday为Date类型的成员
float score;
}student1,student2={10002,″Wang Li″,′f′,5,23,1982,89.5};
//定义Student 类型的变数student1,student2，并对student2初始化
int main( )
{ student1=student2;//将student2各成员的值赋予student1的相应成员
cout<<student1.num<<endl;//输出student1中的num成员的值
cout<<student1.sex<<endl;//输出student1中的sex成员的值cout<<student1.birthday.month<<′/′<<student1.birthday.day<<′/′ <<student1.birthday.year<<endl;//输出student1中的birthday各成员的值
cout<<student1.score<<endl;
return 0; }
运行结果如下：
10002 Wang Li f 5/23/1982 89.5 7.1.4
数组
一个结构体变数中可以存放一组数据（如一个学生的学号、姓名、成绩等数据）。如果有10个学生的数据需要参加运算，显然应该用数组，这就是结构体数组。结构体数组与以前介绍过的数值型数组的不同之处在于：
每个数组元素都是一个结构体类型的数据，它们都分别包括各个成员项。
定义
定义结构体数组和定义结构体变数的方法相仿，定义结构体数组时只需声明其为数组即可。如
{ int num;
char name[20];
char sex;
int age;
float score;
char addr[30];
};
Student stu[3];//定义Student类型的数组stu
也可以直接定义一个结构体数组，如
struct Student
{ int num;
char name[20];
char sex;
int age;
float score;
char addr[30];
}stu[3];
或
struct
{ int num;
char name[20];
char sex;
int age;
float score;
char addr[30];
}stu[3];
结构体数组的初始化与其他类型的数组一样，对结构体数组可以初始化。如
struct Student
{
int num;
char name[20];
char sex;
int age;
float score;
char addr[30];
}stu[3]={
{10101,″Li Lin″, ′M′, 18,87.5, ″103 Beijing Road″},
{10102,″Zhang Fun″,′M′，19,99, ″130 Shanghai Road″},
{10104,″Wang Min″,′F′, 20,78.5, ″1010 Zhongshan Road″}};
定义数组stu时，也可以不指定元素个数，即写成以下形式：
stu[ ]={{…},{…},{…}}；
编译时，系统会根据给出初值的结构体常量的个数来确定数组元素的个数。
一个结构体常量应包括结构体中全部成员的值。当然，数组的初始化也可以用以下形式：
Student stu[ ]={{…},{…},{…}};//已事先声明了结构体类型Student
由上可以看到，结构体数组初始化的一般形式是在所定义的数组名的后面加上 ={初值表列};
套用举例
下面举一个简单的例子来说明结构体数组的定义和引用。
例7.2对候选人得票的统计程式。设有3个候选人，最终只能有1人当选为领导。今有10个人参加投票，从键盘先后输入这10个人所投的候选人的名字，要求最后输出这3个候选人的得票结果。可以定义一个候选人结构体数组，包括3个元素，在每个元素中存放有关的数据。
程式如下：
#include <iostream>
struct Person//声明结构体类型Person
{
char name[20];
int count;
}Person leader[3]={″Li″,0,″Zhang″,0,″Fun″,0};
//定义Person类型的数组，内容为3个候选人的姓名和当前的得票数
int main( )
{
int i,j;
char leader_name[20];
//leader_name为投票人所选的人的姓名
for(i=0;i<10;i++) {cin>>leader_name;
//先后输入10张票上所写的姓名
for(j=0;j<3;j++)//将票上姓名与3个候选人的姓名比较
if(strcmp(leader_name,leader[j].name)==0) leader[j].count++;
//如果与某一候选人的姓名相同，就给他加一票
}
cout<<endl;
for(i=0;i<3;i++)//输出3个候选人的姓名与最后得票数
{cout<<leader[i].name<<″:″<<leader[i].count<<endl;}
return 0;
}
运行情况如下：
Zhang↙ (每次输入一个候选人的姓名)
Li↙
Fun↙
Li↙
Zhang↙
Li↙
Zhang↙
Li↙
Fun↙
Wang↙
Li:4 (输出3个候选人的姓名与最后得票数)
Zhang:3
Fun:2
程式定义一个全局的结构体数组leader,它有3个元素，每一元素包含两个成员，即name（姓名）和count(得票数)。在定义数组时使之初始化，使3位候选人的票数都先置零。
在这个例子中，也可以不用字元数组而用string方法的字元串变数来存放姓名数据，程式可修改如下：
#include <iostream>
#include <string>
using namespace std;
struct Person
{
string name;//成员name为字元串变数
int count;
};
int main( )
{
Person leader[3]={″Li″,0,″Zhang″,0,″Fun″,0};
int i,j;
string leader_name;// leader_name为字元串变数
for(i=0;i<10;i++)
{
cin>>leader_name;
for(j=0;j<3;j++)
if(leader_name==leader[j].name) leader[j].count++
//用“==”进行比较
}
cout<<endl;
for(i=0;i<3;i++)
{cout<<leader[i].name<<″:″<<leader[i].count<<endl;}
return 0;
}
指针
一个结构体变数的指针就是该变数所占据的记忆体段的起始地址。可以设一个指针变数，用来指向一个结构体变数，此时该指针变数的值是结构体变数的起始地址。
指针变数也可以用来指向结构体数组中的元素。
类型一
指向结构体变数的指针引用结构体变数中的成员
下面通过一个简单例子来说明指向结构体变数的指针变数的套用。
例 指向结构体变数的指针的套用。
#include <iostream>
#include <string>
using namespace std;
int main( )
{
struct Student
//声明结构体类型student
{ int num;
char sex;
float score;
};
Student stu;
//定义Student类型的变数stu
Student *p=&stu;
//定义p为指向Student类型数据的指针变数并指向stu
stu.num=10301;
//对string变数可以直接赋值
stu.sex=′f′;
stu.score=89.5;
cout<<stu. num<<″ ″<<″ ″<<stu.sex<<″ ″<<
stu.score<<endl;
cout<<p -> num<<″ ″<<(*p).name<<″ ″<<(*p).sex<<″ ″<<
(*p).score<<endl;
return 0;
}
程式运行结果如下：
10301 Wang Fun f 89.5 (通过结构体变数名引用成员)
10301 Wang Fun f 89.5 (通过指针引用结构体变数中的成员)
两个cout语句输出的结果是相同的。
为了使用方便和使之直观，C++提供了指向结构体变数的运算符->，
例如p->num表示指针p当前指向的结构体变数中的成员num。
p->num 和(*p).num等价。
同样，p->name等价于(*p).name。
也就是说，以下3种形式等价：
① 结构体变数.成员名。如stu.num。
② (*p).成员名。如(*p).num。
③ p->成员名。如p->num。
“->”称为指向运算符。
请分析以下几种运算：
p->n 得到p指向的结构体变数中的成员n的值。
p->n++ 得到p指向的结构体变数中的成员n的值，用完该值后使它加1。
++p->n 得到p指向的结构体变数中的成员n的值，并使之加1，然后再使用它。
类型二
用结构体变数和指向结构体变数的指针构成鍊表
鍊表是一种常见的重要的数据结构。
鍊表有一个“头指针”变数，以head表示，它存放一个地址。该地址指向一个元素。
鍊表中的每一个元素称为“结点”，每个结点都应包括两个部分：
一是用户需要用的实际数据，
二是下一个结点的地址。
可以看到鍊表中各元素在记忆体中的存储单元可以是不连续的。要找某一元素，可以先找到上一个元素，根据它提供的下一元素地址找到下一个元素。
可以看到，这种鍊表的数据结构，必须利用结构体变数和指针才能实现。
可以声明一个结构体类型，包含两种成员，一种是用户需要用的实际数据，另一种是用来存放下一结点地址的指针变数。
例如，可以设计这样一个结构体类型：
struct Student
{
int num;
float score;
Student *next;//next指向Student结构体变数
};
其中成员num和score是用户需要用到的数据，相当于图7.8结点中的A,B,C,D。next是指针类型的成员，它指向Student类型数据（就是next所在的结构体类型）。用这种方法就可以建立鍊表。
每一个结点都属于Student类型，在它的成员next中存放下一个结点的地址，程式设计者不必知道各结点的具体地址，只要保证能将下一个结点的地址放到前一结点的成员next中即可。
下面通过一个例子来说明如何建立和输出一个简单鍊表。
例 建立一个简单鍊表，它由3个学生数据的结点组成。输出各结点中的数据。
#define NULL 0
#include <iostream>
struct Student
{
long num;
float score;
struct Student *next;
};
int main( )
{
Student a,b,c,*head,*p;
a. num=31001;
a.score=89.5;//对结点a的num和score成员赋值
b. num=31003;
b.score=90;//对结点b的num和score成员赋值
c. num=31007;
c.score=85;//对结点c的num和score成员赋值
head=&a;//将结点a的起始地址赋给头指针head
a.next=&b; //将结点b的起始地址赋给a结点的next成员
b.next=&c; //将结点c的起始地址赋给b结点的next成员
c.next=NULL; //结点的next成员不存放其他结点地址
p=head; //使p指针指向a结点
do
{
cout<<p->num<<″ ″<<p->score<<endl; //输出p指向的结点的数据
p=p->next; //使p指向下一个结点
} while (p!=NULL); //输出完c结点后p的值为NULL
return 0;
}
请读者考虑：
①各个结点是怎样构成鍊表的。
②p起什幺作用？
本例是比较简单的，所有结点(结构体变数)都是在程式中定义的，不是临时开闢的，也不能用完后释放，这种鍊表称为静态鍊表。对各结点既可以通过上一个结点的next指针去访问，也可以直接通过结构体变数名a,b,c去访问。
动态鍊表则是指各结点是可以随时插入和删除的，这些结点并没有变数名，只能先找到上一个结点，才能根据它提供的下一结点的地址找到下一个结点。只有提供第一个结点的地址，即头指针head，才能访问整个鍊表。如同一条铁链一样，一环扣一环，中间是不能断开的。
函式参数
将一个结构体变数中的数据传递给另一个函式，有下列3种方法：
(1) 用结构体变数名作参数。一般较少用这种方法。
(2) 用指向结构体变数的指针作实参，将结构体变数的地址传给形参。
(3) 用结构体变数的引用变数作函式参数。
下面通过一个简单的例子来说明，并对它们进行比较。
例有一个结构体变数stu，内含学生学号、姓名和3门课的成绩。要求在main函式中为各成员赋值，在另一函式print中将它们的值输出。
方法一
用结构体变数作函式参数
#include <iostream>
#include <string>
using namespace std;
{ int num;
float score[3];
};
int main( )
{
void print(Student);//函式声明，形参类型为结构体Student
Student stu;//定义结构体变数
stu.num=12345;//以下5行对结构体变数各成员赋值
stu.score[0]=67.5;
stu.score[1]=89;
stu.score[2]=78.5;
print(stu);//调用print函式，输出stu各成员的值
return 0;
}
void print(Student st)
{
cout<<st.num<<″ ″<<″ ″<<st.score[0]
<<″ ″ <<st.score[1]<<″ ″<<st.score[2]<<endl;
}
运行结果为
12345 67.5 89 78.5
方法二
用指向结构体变数的指针作实参
#include <iostream>
#include <string>
using namespace std;
struct Student
{
int num; string name;//用string类型定义字元串变数
float score[3];
}stu={12345,″Li Fung″,67.5,89,78.5};//定义结构体student变数stu并赋初值
int main( )
{
void print(Student *);//函式声明，形参为指向Student类型数据的指针变数
Student *pt=&stu;//定义基类型为Student的指针变数pt，并指向stu
print(pt);//实参为指向Student类数据的指针变数
return 0;
}
//定义函式，形参p是基类型为Student的指针变数
void print(Student *p)
{
cout<<p->num<<″ ″<<p->name<<″ ″<<p->score[0]<<″ ″ <<
p->score[1]<<″ ″<<p->score[2]<<endl;
}
调用print函式时，实参指针变数pt将stu的起始地址传送给形参p（p也是基类型为student的指针变数）。这样形参p也就指向stu，见图7.10。
在print函式中输出p所指向的结构体变数的各个成员值，它们也就是stu的成员值。在main函式中也可以不定义指针变数pt，而在调用print函式时以&stu作为实参，把stu的起始地址传给实参p。
图7.10
方法三
用结构体变数的引用作函式参数
#include <iostream>
#include <string>
using namespace std;
struct Student
{
int num;
string name;
float score[3];
}stu={12345,″Li Li″,67.5,89,78.5};
void main( )
{
void print(Student &);
//函式声明，形参为Student类型变数的引用
print(stu);
//实参为结构体Student变数
}
//函式定义，形参为结构体Student变数的引用
void print(Student &stud)
{
cout<<stud.num<<″ ″<<″ ″<<stud.score[0]
<<″ ″ <<stud.score[1]<<″ ″<<stud.score[2]<<endl;
}
程式(1)用结构体变数作实参和形参，程式直观易懂，效率是不高的。
程式(2)採用指针变数作为实参和形参，空间和时间的开销都很小，效率较高。但程式（2）不如程式(1)那样直接。
程式(3)的实参是结构体Student类型变数，而形参用Student类型的引用，虚实结合时传递的是stu的地址，因而效率较高。它兼有(1)和(2)的优点。
引用变数主要用作函式参数，它可以提高效率，而且保持程式良好的可读性。在本例中用了string方法定义字元串变数，在某些C++系统中不能运行这些程式，读者可以修改程式，使之能在自己所用的系统中运行。
分配
在软体开发过程中，常常需要动态地分配和撤销记忆体空间，例如对动态鍊表中结点的插入与删除。
在C语言中是利用库函式malloc和free来分配和撤销记忆体空间的。
sizeof
C++提供了较简便而功能较强的运算符new和delete来取代malloc和free函式。
注意： new和delete是运算符，不是函式，因此执行效率高。
虽然为了与C语言兼容，C++仍保留malloc和free函式，但建议用户不用malloc和free函式，而用new和delete运算符。
new运算符的例子：
new int;//开闢一个存放整数的存储空间，返回一个指向该存储空间的地址(即指针)
new int(100);//开闢一个存放整数的空间，并指定该整数的初值为100，返回一个指向该存储空间的地址
new char[10];//开闢一个存放字元数组(包括10个元素)的空间，返回首元素的地址
new int[5][4];//开闢一个存放二维整型数组(大小为5*4)的空间，返回首元素的地址
float *p=new float (3.14159);//开闢一个存放单精度数的空间，并指定该实数的初值为//3.14159，将返回的该空间的地址赋给指针变数p
new运算符使用的一般格式为
new 类型 [初值]
用new分配数组空间时不能指定初值。如果由于记忆体不足等原因而无法正常分配空间，则new会返回一个空指针NULL，用户可以根据该指针的值判断分配空间是否成功。
delete运算符使用的一般格式为
delete [ ] 指针变数
例如要撤销上面用new开闢的存放单精度数的空间(上面第5个例子)，应该用
delete p；
前面用“new char[10];”开闢的字元数组空间，如果把new返回的指针赋给了指针变数pt，则应该用以下形式的delete运算符撤销该空间：
delete [] pt；//在指针变数前面加一对方括弧，表示是对数组空间的操作
例 开闢空间以存放一个结构体变数。
#include <iostream>
#include <string>
using namespace std;
struct Student //声明结构体类型Student
{ string name;
int num;
char sex;
};
int main( )
{ Student *p; //定义指向结构体类型Student的数据的指针变数
p=new Student; //用new运算符开闢一个存放Student型数据的空间
p->name=″Wang Fun″; //向结构体变数的成员赋值
p->num=10123;
p->sex='m';
cout<<p->name<<endl<<p->num
<<endl<<p->sex<<endl;//输出各成员的值
delete p;//撤销该空间
return 0;
}
运行结果为
Wang Fun 10123 m
在动态分配/撤销空间时，往往将这两个运算符和结构体结合使用，是很有效的。可以看到：
要访问用new所开闢的结构体空间，无法直接通过变数名进行，只能通过指针p进行访问。如果要建立一个动态鍊表，必须从第一个结点开始，逐个地开闢结点并输入各结点数据，通过指针建立起前后相链的关係。