文章标题

一。结构体类型

include

using namespace std;

struct Date //声明一个结构体类型Date
{
int month;
int day;
int year;
};

struct Student //struct是声明结构体类型必须使用的关键字
{
int num;
char name[20];//定义一个字符数组（0=<字符数量<=20)，可以容纳20个字符
char sex;//一个字符
int age;
Date birthday; //Date是结构体类型，birthday是Date类型的成员
float score;
char addr[30];
};
//Student student1,student2;//定义结构体变量，如果要初始化，最好合并为以下两行代码
Student student1={10001,”wang li”,’F’,19,1,1,2000,100,”Beijing”};
Student student2={10002,”zhangzhen”,’M’,23,1,1,2000,100,”shanghai”};

int main()
{
student1=student2;
cout<<”num:”<

//6.可以引用结构体变量成员的地址，也可以引用结构体变量的地址。eg:cout<<&student1;cout<<&student1.age

二。结构体数组
struct Student //struct是声明结构体类型必须使用的关键字
{
int num;
char name[20];//定义一个字符数组（0=<字符数量<=20)，可以容纳20个字符
char sex;//一个字符
int age;
Date birthday; //Date是结构体类型，birthday是Date类型的成员
float score;
char addr[30];
};
Student stu[3]={{10101,”liming”,’m’,18,1,1,2000,100,”beijing”},{10102,”wang er”,”m’,24,1,1,2000,100,”shanghai”},
{10103,”zhang si”,’f’,23,1,1,2000,100,”jinan”}};//定义Student类型的数组stu
//Student stu[]={{…},{…},{…}};
实例：

include

using namespace std;
struct Person //声明结构体类型
{
char name[20];
int count;
};
int main()
{
Person leader[]={“li”,0,”zhang”,0,”sun”,0};//定义Person类型的数组，内容为3个候选人的姓名和当前的得票数
int i,j;
char leader_name[20]; //leader_name为投票人所选人的姓名
cout<<”input the name of 10 tips”<

}

@如果不用字符数组而用string方法的字符串变量来存放姓名数据，修改如下：

include

include

using namespace std;
struct Person
{
string name;
int count;
}leader[3];
//Person leader[3]={{“li”,0},{“zhang”,0},{“sun”,0}};

int main()
{
leader[0].name=”li”;
leader[0].count=0;
leader[1].name=”zhang”;
leader[1].count=0;
leader[2].name=”sun”;
leader[2].count=0;
int i,j;
string 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<

include

include

using namespace std;
int main()
{
struct Student //声明结构体类型
{
int num;
string name;
char sex;
float score;
};
Student stu; //定义Student类型的变量stu
Student *p=&stu; //定义p为指向Student类型数据的指针变量并指向stu
stu.num=10301;
stu.name=”Wang Feng”;
stu.sex=’f’;
stu.score=89.5;
cout<

}

//@结构体类型数据作为函数参数
//1.用结构体变量名作参数。=采取“值传递”的方式，将结构体变量所占的内存单元的内容全部顺序传递给形参。形参也必须是同类型的结构体变量。
//这种值传递方式在时间和空间上开销较大。此外，由于采用值传递方式，如果在执行被调用函数期间改变了形参的值，该值不能返回主调函数。
//2.用指向结构体变量的指针做实参，将结构体变量的地址传给形参。
//3.用结构体变量的引用做函数参数，它就成为实参（结构体变量）的别名。

//1.用结构体变量名作参数。

include

include

using namespace std;
struct Student
{
int num;
string name;
float score[3];
};

int main()
{
void print(Student);//函数声明，形参类型为结构体Student
Student stu;//定义结构体变量
stu.num=12345;
stu.name=”Li Fang”;//stu.name=”Li Fang”;
stu.score[0]=67.5;
stu.score[1]=89;
stu.score[2]=87.5;
print(stu); //调用print函数，输出stu各成员的函数
return 0;
}
void print(Student stu)
{
cout<

include

include

using namespace std;
struct Student
{
int num;
string name;
float score[3];
}stu;//定义结构体Student变量stu并赋值

int main()
{
void print(Student *);//函数声明，形参为指向Student类型数据的指针变量

stu.num=12345;stu.name="Li Fang";//stu.name="Li Fang";stu.score[0]=67.5;stu.score[1]=89;stu.score[2]=87.5;Student *pt=&stu;//定义基类型为Student的指针变量pt,并指向stuprint(pt);   //实参为指向结构体变量stu指针变量return 0;

}
void print(Student *p) //定义函数，形参p是基类型为Student的指针变量
{
cout<<(*p).num<<” “<<(*p).name<<” “<<(*p).score[0]<<” “<<(*p).score[1]<<” “<<(*p).score[2]<

}

//3.用结构体变量的引用做函数参数

include

include

using namespace std;
struct Student
{
int num;
string name;
float score[3];
}stu;//定义结构体Student变量stu并赋值

int main()
{
stu.num=12345;
stu.name=”Li Fang”;//stu.name=”Li Fang”;
stu.score[0]=67.5;
stu.score[1]=89;
stu.score[2]=87.5;
void print(Student &);//函数声明
print(stu); //实参为结构体Student变量
return 0;
}
void print(Student &stud) //定义函数，形参为结构体Student变量的引用
{
cout<

}

//用new和delete运算符进行动态分配和撤销存储空间
//new 类型[初值]
//特别的，用new分配数组空间时不能指定初值。
//delete 指针变量 (对变量)
//delete [] 指针变量 (对数组)

//new int; //开辟一个存放整数的存储空间，返回一个指向该存储空间的地址（即指针）
//new int(100); //开辟存放一个整数的空间，并指定该整数的初值为100，返回一个指向该存储空间的地址
//new char[10]; //开辟一个存放字符数组（包括10个元素）的空间，返回字符数组首元素的地址
//char *pt=new char[10] delete [] pt;
//new int[5][4]; //开辟一个存放二维整型数组的空间，返回首元素的地址
//float *p=new float(3.14159) //开辟一个存放单精度数的空间，并指定该数的初值为3.14159，将返回的该空间地址赋给指针变量p
//delete p;

include

include

using namespace std;
struct Student
{
string name;
int num;
char sex;
};
int main()
{
Student *p;//定义指向结构体类型Student的数据的指针变量p
p=new Student;//用new运算符开辟一个存放Student型数据的空间，把地址赋给p
p->name=”Wang Feng”;//向结构体变量的成员赋值
p->num=10123;
p->sex=’m’;
cout<name<

}

//@链表

include

using namespace std;
struct Student
{
long num;
float score;
struct Student *next;
};
int main()
{
struct Student a,b,c,*head,*p;
a.num=10101;
a.score=89.5;
b.num=10103;
b.score=90;
c.num=10105;
c.score=85;
head=&a;
a.next=&b;
b.next=&c;
c.next=NULL;
p=head;
do{
cout<num<<” “<score<

//3.p起什么作用？没有它行不行？

@建立链表的函数如下；

include

using namespace std;
struct Student
{
long num;
float score;
Student *next;
};
int n; //定义n为全局变量，本文件中各个函数均可用它
Student *creat(void)//定义函数，此函数带回一个指向链表头的指针
{
Student *head;
Student *p1,*p2;
n=0;
p1=p2=new Student;//开辟一个新单元，并使p1,p2指向它
cin>>p1->num>>p1->score;
head=NULL;
while(p1->num!=0)
{
n=n+1;
if(n==1)head=p1;
else p2->next=p1;//让p1指向新开的节点，p2指向链表中最后一个节点，把p1所指的节点连接在p2所指的节点后面。
p2=p1;
p1=new Student;//开辟新节点
cin>>p1->num>>p1->score;
}
p2->next=NULL;
return(head);
}

//可以在main函数中调用creat函数，调用creat函数后，建立一个单向动态链表，并返回链表第一个节点的指针。

@编写一个输出链表的函数print。假设本文本中已有以下程序行。

include

using namespace std;
struct student
{
long num;
float score;
student *next;
};
int n;

void print(student *head)
{
student *p;
cout<

}

@p115

include

using namespace std;
struct student
{
long num;
float score;
student *next;
};
int n;
student *del(student *head,long num)
{
student *p1,*p2;
if(head==NULL) //是空表
{
cout<<”list null!”<

}

//共用体类型
union Data //声明一个名为Data的共用体类型并定义了3个共用体变量a,b,c;
{
int i;
char ch;
double d;
}a,b,c;
//共用体和结构体的不同之处在于：系统为结构体中各成员分别分配存储单元，而共用体则是各成员共占一段存储单元。例如上面的定义

//是把一个整型成员、一个字符型成员、一个双精度型成员安排在同一个地址开始的内存单元中。

//枚举类型
//声明枚举类型用enum开头。
//声明枚举类型的一般形式为：enum 枚举类型名 {枚举常量表}；
//在声明了枚举类型后，可以用它来定义变量。如：weekday workday,week_end;在c语言中，枚举类型名包含关键字enum，即 enum weekday workday,week_day
//也可以在声明枚举类型的同时定义枚举变量，如enum{sun,mon,tue,wed,thu,fri,sat}workday,week_end;
//枚举元素的名字本身并没有特定的含义。
//说明：
//1.枚举元素按常量处理，故称枚举常量。不能对它们赋值。
//2.枚举元素作为常量，它们是有值的，其值是一个整数，编译系统按定义时的顺序对它们赋值为0,1,2,3,…。在上面的声明中，sun的值为0，mon的值为1…
//如果有赋值语句：workday=mon;//把枚举常量mon的值赋给枚举变量workday,workday的值等于1，这个值的是可以输出的。如：cout<

include

include//在输出时要用到setw控制符

using namespace std;
int main()
{
enum color{red,yellow,blue,white,black};//声明枚举类型color
color pri;//定义color类型的变量pri
int i,j,k,n=0,loop;//n是累计不同颜色的组合数
for(i=red;i<=black;i++)//当i为某一颜色时
for(j=red;j<=black;j++)//当j为某一颜色时
if(i!=j) //当前两个球的颜色不同
{
for(k=red;k<=black;k++)//只有前两个球的颜色不同，才需要检查第3个球的颜色
if((k!=i)&&(k!=j)) //3个球的颜色都不同
{
n=n+1;//使累计值n加1
cout<

}

/*用typedef声明新的类型名，来代替已有的类型名
//typedef int INTEGER;//指定用标识符INTEGER代表int类型
//typedef float REAL;//指定用REAL代表float类型
//这样，以下两行等价：
//int i,j;float a,b;
//INTEGER i,j;REAL a,b;
//如果在一个程序中，整型变量是专门用来计数的，可以用COUNT来作为整型类型名：
//typedef int COUNT;//指定用COUNT代表int类型
//COUNT i,j;//将变量i，j定义为COUNT类型，即int类型
//也可以对一个结构体类型声明一个新的名字；
//typedef struct //注意在struct之前用了关键字typedef，表示是声明新类型名
{
int month;
int day;
int year;
}DATE;//注意DATE是新类型名，而不是结构体变量名
//所声明的新类型名DATE代表上面指定的一个结构体类型。这样就可以用DATE定义变量：
DATE birthday;
DATE *p; //p为指向此结构体类型数据的指针
//1.typedef int NUM[100]; //声明NUM为整型数组类型，包含100个元素
//NUM n; //定义n为包含100个整型元素的数组
//2.typedef char * STRING; //声明STRING为char *类型，即字符指针类型
//STRING P,S[10]; //定义p为char 型指针变量，s为char 类型的指针数组（有10个元素）
//3.typedef int(* POINTER)() //声明POINTER为指向函数的指针类型，函数返回整型值
//POINTER P1,P2; //P1,P2为POINTER类型的指针变量
//归纳起来，声明一个新的类型名的方法是：
1.先按定义变量的方法写出定义语句（如：int i;）。
2.将变量名换成新类型名（如：将i换成COUNT,即 int COUNT;)。
3.在最前面加typedef.
4.然后可以用新类型名（如COUNT)去定义变量。
再以声明上述的数组类型为例来说明：
1.先按定义数组形式书写：int n[100];
2.将变量名n换成自己指定的类型名：int NUM[100];
3.在前面加上typedef,得到typedef int NUM[100];
4.用新类型名NUM来定义变量：NUM n;
习惯上常把用typedef声明的类型名用大写字母表示，以便与系统提供的标准类型标识符相区别。
说明：
1.用typedef声明的新类型名又称为typedef类型名，或typedef名字。
2.用typedef只是对已经存在的类型增加一个类型名，而没有创建新的类型。
3.可以用typedef声明新类型名，但不能用来定义变量。
4.用typedef可以声明数组类型，字符串类型，使用比较方便。如原先这样定义数组：
int a[10],b[10],c[10],d[10];
由于都是一维数组，大小也相同，可以将大小为10的一维整型数组声明为一个新类型：
typedef int ARR[10];
然后用ARR去定义数组变量：
ARR a,b,c,d;
ARR为一维整型数组类型，它包含10个元素。因此，a,b,c,d都被定义为一维整型数组，含10个元素。
可以看到，用typedef可以将声明数组类型和定义数组变量分离开来，即先声明数组类型，再利用数组类型定义数组变量。
同样可以定义字符串类型、指针类型等。如：
int（*p)();
p是指向函数的指针，该函数为整型（函数返回一个整数）。这种形式不容易记忆，且易和其他的指针类型混淆。可以用typedef声明
一个新类型名：
typedef int（ * Pointer_to_function)();
声明Pointer_to_function是指向int型函数的指针类型。这样就可以在程序中这样定义指向int型函数的指针变量：
Pointer_to_function pt1,pt2;//定义指向int型函数的指针变量pt1,pt2
5.一个软件开发单位中的程序员往往会在不同源文件中用到一些类型（尤其是像数组、指针、结构体、共用体等类型数据）时，常用typedef声明这些数据
类型，把他们单独放到一个头文件中，程序员在写程序时只需用#include指令把该头文件包括到本文件中，就可以使用这些typedef类型名，以方便编程。
6.使用typedef类型名，有利于程序的通用与移植。例如将”int a,b,c;”改为”long a,b,c;”。如果程序中有多处用int定义变量，则要改动多处。现可以用一个
INTEGER来声明int：
typedef int INTEGER;//原来这样写
在程序中所有整型变量都用INTEGER定义，这样这些变量都是int类型的，按两个字节分配空间。在移植时只须改动typedef定义语句即可，可改为
typedef long INTEGER; //在移植后改为这样
在新的编译系统中，把用INTEGER定义的变量作为long类型处理，按4个字节分配空间。

*/