课件-第5章构造数据类型newnew

第5章构造数据类型C++语言程序设计教程第5章构造数据类型制作人：沈显君杨进才第5章构造数据类型1.掌握枚举类型的使用;2.深入理解数组的概念,掌握数组应用的一般方法；3.深入理解指针的概念，掌握指针的使用；4.注意指针与数组的区别，会使用多重指针以及指针与数组的多种混合体，会分配动态数组；5.理解字符串的概念，会使用字符串；6.理解引用的概念，掌握引用型函数参数的用法；7.掌握结构与联合类型的使用，并注意二者的区别。学习目标

C++语言程序设计教程第5章构造数据类型5.1枚举类型—enum

enumeration[i.nju:mə'reiʃən]

1.枚举类型的定义：

“枚举”（）是指将变量所有可能的取值一一列举出来，变量的取值只限于列举出来的常量。

枚举类型的声明的一般形式如下

:

枚举类型名以及枚举常量为标识符，遵循标识符的取名规则。在定义一个枚举类型时，定义了多个常量，供枚举类型变量取值，称此常量为枚举常量。当没给各枚举常量指定值时，其值依次默认为0、1、2、…；在定义枚举类型时，也可使用赋值号另行指定枚举常量的值。

enum枚举类型名

{枚举常量1,枚举常量2,…,枚举常量n}；枚举！C++语言程序设计教程第5章构造数据类型5.1枚举类型枚举类型的定义：例1：

enumweekday{SUN,MON,TUE,WED,THU,FRI,SAT}；

定义了7个枚举常量以及枚举类型weekday。枚举常量具有默认的整数与之对应：SUN的值为0、MON的值为1、TUE为2、…、SAT为6。例2：

enumcity{Beijing,Shanghai,Tianjin=5,Chongqing}；枚举常量Beijing的值为0，Shanghai的值为1，Tianjin的值指定为5。对于指定值后面的没有指定值的枚举常量，编译器会将前一个常量值加1(下一个整数)赋给它，所以Chongqing的值为6。C++语言程序设计教程第5章构造数据类型5.1枚举类型枚举类型的定义说明:枚举类型定义了以后就可以使用枚举常量、使用用枚举类型来定义变量，定义枚举变量的方法与定义其它变量的方法一样。

例如：

enumcitycity1,city2;citycity1,city2;

用两种方法定义了city1、city2两个枚举类型的变量名。枚举类型变量也可以在定义枚举类型的同时定义例如：

enumcity{Beijing,Shanghai,Tianjin=5,Chongqing}city1,city2；

在定义枚举类型的同时定义枚举类型变量可以省略枚举类型名例如：

enum{Beijing,Shanghai,Tianjin=5,Chongqing}city1,city2；在定义变量时，可以顺便给出初值，若不给初值，默认初值为随机的无意义的数。C++语言程序设计教程第5章构造数据类型5.1枚举类型枚举类型的使用：用枚举类型建立枚举变量后就可以对枚举变量实施赋值以及进行其它运算了，对枚举变量进行赋值，其值要求为同一枚举类型。否则，在编译时出错。例如:weekdayd1,d2,d3,d4;d1=SUN;d2=6;//错误

d3=Shanghai;//错误其中对d2所赋之值是整数6，不是枚举常量；可以采用将一个整型值强制转换成同类型的枚举常量赋给枚举变量：枚举常量、枚举类型的变量可进行算术运算、关系运算。对枚举类型实施算术、关系运算时，枚举值转换成整型值参加运算，结果为整型值。所以，如果要将结果赋给枚举变量，还要将结果转换成枚举值。例如：

d1=d1+2;//是错误的，因为结果为int型。需要将它强制转换成枚举型：

d1=(weekday)(d1+2);C++语言程序设计教程第5章构造数据类型5.1枚举类型枚举类型的使用：

枚举常量、枚举类型的变量可直接进行各种形式的关系运算。例如：

if(city1==3)；

if(city2>=Beijing)；

if(Shanghai==1);if(city1>SUN);枚举类型变量不能直接进行输入例如：

cin>>d1;//错误C++语言程序设计教程第4章函数注意:枚举常量是常量，不是变量，所以不能对枚举常量进行赋值。例如：在上例中不能进行赋值Shanghai=Beijing；枚举常量的值不是列举的字符串，其值为整数。编译器对赋给枚举变量的对象(数)进行类型检查，如类型不相符则发出警告。当类型相

同，而值超出此类枚举类型枚举常量范围时，也是正常的。123456789101112/*******************************************************************程序名：p5_1.cpp**功能：

枚举类型的使用，输入城市代号，输出城市名称********************************************************************/#include<iostream>usingnamespacestd;enumcity{Beijing,Shanghai,Tianjin=6,Chongqing};intmain(){intn;cout<<"Inputacitynumber("<<Beijing-1<<"toexit)："<<endl;cin>>n;枚举类型定义C++语言程序设计教程第5章构造数据类型【例5-1】输入城市代号，输出城市名称。

5.1枚举类型131415161718192021222324

while(n>=Beijing){switch(n){caseBeijing:cout<<"Beijing"<<endl;break;caseShanghai:cout<<"Shanghai"<<endl;break;caseTianjin:cout<<"Tianjin"<<endl;break;caseChongqing:cout<<"Chongqing"<<endl;break;default:cout<<"Invalidcitynumber!"<<endl;break;}cin>>n;}return0;}

运行结果：Inputacitynumber(-1toexit)：1↙Shanghai8↙Invalidcitynumber!-1↙

C++语言程序设计教程第5章构造数据类型枚举类型的使用5.1枚举类型5.2数组的概念数组是具有一定顺序关系的若干相同类型变量的集合体，组成数组的变量称为该数组的元素。数组属于构造类型。数组一维数组的声明与引用一维数组的声明类型说明符数组名[常量表达式]；

例如：inta[10];

表示a为整型数组，有10个元素：a[0]...a[9]引用必须先声明，后使用。只能逐个引用数组元素，而不能一次引用整个数组

例如：a[0]=a[5]+a[7]-a[2*3]数组名的构成方法与一般变量名相同。数组一维数组的声明与引用#include<iostream>usingnamespacestd;voidmain(){ intA[10],B[10]; inti; for(i=0;i<10;i++) {

A[i]=i*2-1;

B[10-i-1]=A[i]; }数组

for(i=0;i<10;i++){ cout<<"A["<<i<<"]="<<&A[i]; cout<<"A["<<i<<"]="<<A[i]; cout<<"B["<<i<<"]="<<B[i]<<endl; }}一维数组的存储顺序数组元素在内存中顺次存放，它们的地址是连续的。例如：具有10个元素的数组a，在内存中的存放次序如下：数组名字是数组首元素的内存地址。数组名是一个常量，不能被赋值。a[0]a[1]a[2]a[3]a[4]a[5]a[6]a[7]a[8]a[9]a数组一维数组的初始化可以在编译阶段使数组得到初值：在声明数组时对数组元素赋以初值。

例如：inta[10]={0,1,2,3,4,5,6,7,8,9};可以只给一部分元素赋初值。

例如：inta[10]={0,1,2,3,4};在对全部数组元素赋初值时，可以不指定数组长度。

例如：inta[]={1,2,3,4,5}数组#include<iostream>usingnamespacestd;voidmain(){inti;intf[20]={1,1};//初始化第0、1个数

for(i=2;i<20;i++)f[i]=f[i-2]+f[i-1];//求第2～19个数

for(i=0;i<20;i++)//输出，每行5个数//{if(i%5==0)cout<<endl; cout.width(12);//设置输出宽度为12 cout<<f[i];}}例：用数组来处理求Fibonacci数列问题例：用数组来处理求Fibonacci数列问题运行结果：

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765二维数组的声明及引用数据类型标识符[常量表达式1][常量表达式2]…;例:inta[5][3];

表示a为整型二维数组，其中第一维有5个下标（0~4），第二维有3个下标（0~2），数组的元素个数为15，可以用于存放5行3列的整型数据表格。数组存储顺序按行存放，上例中数组a的存储顺序为：

二维数组的声明类型说明符数组名[常量表达式][常量表达式]例如：floata[3][4];a00a01a02a03a10a11a12a13a20a21a22a23a[0]——a00a01a02a03a[1]——a10a11a12a13

a[2]——a20a21a22a23a可以理解为：引用例如：b[1][2]=a[2][3]/2

下标不要越界二维数组的声明及引用数组18将所有数据写在一个{}内，按顺序赋值例如：inta[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};分行给二维数组赋初值例如：inta[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};可以对部分元素赋初值例如：inta[3][4]={{1},{0,6},{0,0,11}};二维数组的初始化数组19数组作为函数参数数组元素作实参，与单个变量一样。数组名作参数，形、实参数都应是数组名，类型要一样，传送的是数组首地址。对形参数组的改变会直接影响到实参数组。数组例使用数组名作为函数参数主函数中初始化一个矩阵并将每个元素都输出，然后调用子函数，分别计算每一行的元素之和，将和直接存放在每行的第一个元素中，返回主函数之后输出各行元素的和。数组#include<iostream>usingnamespacestd;voidRowSum(intA[][4],intnrow){ intsum; for(inti=0;i<nrow;i++) { sum=0;

for(intj=0;j<4;j++)

sum+=A[i][j]; cout<<"Sumofrow"<<i

<<"is"<<sum<<endl;A[i][0]=sum; }}22voidmain(void){ intTable[3][4]={{1,2,3,4},{2,3,4,5},{3,4,5,6}}; for(inti=0;i<3;i++) { for(intj=0;j<4;j++) cout<<Table[i][j]<<""; cout<<endl; } RowSum(Table,3);

for(inti=0;i<3;i++)

cout<<Table[i][0]}23运行结果：123423453456Sumofrow0is10Sumofrow1is14Sumofrow2i3指针：关于内存地址内存空间的访问方式通过变量名访问通过地址访问地址运算符：&例：intvar;则&var

表示变量var在内存中的起始地址声明例：inti;int*i_pointer=&i;

指向整型变量的指针指针变量的概念概念指针：内存地址，用于

间接访问内存单元指针变量：

用于存放地址的变量20003i_pointer*i_pointeri2000内存用户数据区变量i变量j变量

i_pointer362000200020043010引用例1：i=3;例2：*i_pointer=3;指针指针变量的初始化语法形式

存储类型数据类型*指针名＝初始地址；例：int*pa=&a;注意事项用变量地址作为初值时，该变量必须在指针初始化之前已说明过，且变量类型应与指针类型一致。可以用一个已赋初值的指针去初始化另一个指针变量。指针指针变量的赋值运算指针名=地址“地址”中存放的数据类型与指针类型必须相符。向指针变量赋的值必须是地址常量或变量，不能是普通整数。但可以赋值为整数0，表示空指针。指针的类型是它所指向变量的类型，而不是指针本身数据值的类型，任何一个指针本身的数据值都是unsignedlongint型。允许声明指向void类型的指针。该指针可以被赋予任何类型对象的地址。例：void*general;指针例指针的声明、赋值与使用#include<iostream>usingnamespacestd;voidmain(){ int*i_pointer; //声明int型指针i_pointer inti; //声明int型数i i_pointer=&i; //取i的地址赋给i_pointer i=10; //int型数赋初值

cout<<"Outputinti="<<i<<endl;//输出int型数的值

cout<<"Outputintpointeri="<<*i_pointer<<endl;//输出int型指针所指地址的内容}指针程序运行的结果是：Outputinti=10Outputintpointeri=1030指针变量的算术运算指针与整数的加减运算指针p加上或减去n，其意义是指针当前指向位置的前方或后方第n个数据的地址。这种运算的结果值取决于指针指向的数据类型。指针加一，减一运算指向下一个或前一个数据。例如：y=*px++相当于y=*(px++)

(*和++优先级相同，自右向左运算)指针papa-2pa-1pa+1pa+2pa+3*(pa-2)*pa*(pa+1)*(pa+2)*(pa+3)*(pa-1)short*pa32pb-1pbpb+1pb+2*(pb-1)*pb*(pb+1)*(pb+2)long*pb33关系运算指向相同类型数据的指针之间可以进行各种关系运算。指向不同数据类型的指针，以及指针与一般整数变量之间的关系运算是无意义的。指针可以和零之间进行等于或不等于的关系运算。例如：p==0或p!=0赋值运算向指针变量赋的值必须是地址常量或变量，不能是普通整数。但可以赋值为整数0，表示空指针。指针变量的关系运算指针指向数组元素的指针声明与赋值例：inta[10],*pa;pa=&a[0];或pa=a;通过指针引用数组元素经过上述声明及赋值后：*pa就是a[0]，*(pa+1)就是a[1]，...，*(pa+i)就是a[i].a[i],*(pa+i),*(a+i),pa[i]都是等效的。不能写a++，因为a是数组首地址是常量。指针例设有一个int型数组a，有10个元素。用三种方法输出各元素：使用数组名和下标使用数组名和指针运算使用指针变量指针main(){inta[10];inti;for(i=0;i<10;i++)cin>>a[i];cout<<endl;for(i=0;i<10;i++)cout<<a[i];}使用数组名和下标37main(){inta[10];inti;for(i=0;i<10;i++)cin>>a[i];cout<<endl;for(i=0;i<10;i++)cout<<*(a+i);}使用数组名指针运算使用指针变量main(){inta[10];int*p,i；

for(i=0;i<10;i++)cin>>a[i];cout<<endl;for(p=a;p<(a+10);p++)cout<<*p;}指针数组数组的元素是指针型例：int*pa[2];

由pa[0],pa[1]两个指针组成指针例利用指针数组存放单位矩阵#include<iostream>usingnamespacestd;voidmain(){ intline1[]={1,0,0};//声明数组，矩阵的第一行

intline2[]={0,1,0};//声明数组，矩阵的第二行

intline3[]={0,0,1};//声明数组，矩阵的第三行

int*p_line[3]; //声明整型指针数组

p_line[0]=line1; //初始化指针数组元素

p_line[1]=line2; p_line[2]=line3;指针

//输出单位矩阵

cout<<"Matrixtest:"<<endl; for(inti=0;i<3;i++) //对指针数组元素循环

{ for(intj=0;j<3;j++) //对矩阵每一行循环

{cout<<p_line[i][j]<<"";} cout<<endl; }}输出结果为：Matrixtest:1,0,00,1,00,0,142以指针作为函数参数以地址方式传递数据，可以用来返回函数处理结果。实参是数组名时形参可以是指针。

指针与函数例题目：读入三个浮点数，将整数部分和小数部分分别输出#include<iostream>usingnamespacestd;voidsplitfloat(floatx,int*intpart,

float*fracpart){//形参intpart、fracpart是指针

*intpart=int(x); //取x的整数部分

*fracpart=x-*intpart;//取x的小数部分}

指针与函数voidmain(void){ inti,n; floatx,f;

cout<<"Enterthree(3)floatingpointnumbers"

<<endl; for(i=0;i<3;i++) { cin>>x; splitfloat(x,&n,&f);//变量地址做实参 cout<<"IntegerPartis"<<n

<<"FractionPartis"<<f<<endl; }}45运行结果：Enterthree(3)floatingpointnumbers4.7IntegerPartis4FractionPartis0.78.913IntegerPartis8FractionPartis0.913-4.7518IntegerPartis-4FractionPartis-0.751846指针型函数当函数的返回值是地址时，该函数就是指针形函数。声明形式存储类型数据类型*函数名()int*getAddress(inti){return&i;}

指针与函数声明形式存储类型数据类型(*函数指针名)();

含义：数据指针指向数据存储区，而函数指针指向的是程序代码存储区。指向函数的指针

指针与函数例函数指针#include<iostream>usingnamespacestd;voidprint_stuff(floatdata_to_ignore);voidprint_message(floatlist_this_data);voidprint_float(floatdata_to_print);void(*function_pointer)(float); voidmain() { floatpi=(float)3.14159; floattwo_pi=(float)2.0*pi;

指针与函数

print_stuff(pi);

function_pointer=print_stuff;

function_pointer(pi);

function_pointer=print_message;

function_pointer(two_pi);

function_pointer(13.0);

function_pointer=print_float;

function_pointer(pi);print_float(pi);}50voidprint_stuff(floatdata_to_ignore){ cout<<"Thisistheprintstufffunction.\n";}voidprint_message(floatlist_this_data){ cout<<"Thedatatobelistedis"<<list_this_data<<endl;}voidprint_float(floatdata_to_print){ cout<<"Thedatatobeprintedis"<<data_to_print<<endl;}51运行结果：Thisistheprintstufffunction.Thisistheprintstufffunction.Thedatatobelistedis6.283180Thedatatobelistedis13.000000Thedatatobeprintedis3.141590Thedatatobeprintedis3.14159052动态内存分配

在C++中，动态内存分配技术可以保证程序在运行过程中根据实际需要申请适量的内存，使用结束后还可以释放。C++通过new运算和delete运算来实现动态内存分配。

1.new运算

new运算的作用是按指定类型和大小动态的分配内存。基本语法形式为：

其中：数据类型可以是基本数据类型，也可以是用户自定义的复杂数据类型。

new运算符在堆(内存)中创建一个由类型名指定类型的对象，如果创建成功，

返回对象的地址；否则返回空指针NULL。初值列表给出被创建对象的初始值。由于返回的是地址，所以要用事先定义一个类型相同的指针变量来存储这个地址。指针变量=new类型名(初值列表);delete指针变量;C++语言程序设计教程第5章构造数据类型动态内存分配1）new创建指定类型对象

例①：int

*ip;ip=new

int(5);//ip指向1个初值为5的int型对象也可以使用一条语句定义：int*ip=newint(5);deleteip;C++语言程序设计教程第5章构造数据类型说明:

首先定义了一个整型指针ip;然后申请内存，创建一个int型数据对象，并将该数据对象初始化为5;最后返回创建的数据对象的地址，存入ip。动态内存分配2）new创建动态数组时

使用new运算可创建一个数据对象，也可以创建同类型的多个对象----数组。由于数组大小可以动态给定，所创建的对象称为动态数组。new创建动态数组时，需要给出数组的结构说明。

其语法格式如下：

其中：下标表达式与数组初始化时的常量表达式不同，可以是变量表达式。用new申请失败时，返回NULL。申请一个动态数组，往往需要较大的空间，因此，在程序中需要对new的返回值进行判断，看是否申请成功。例②：

int

*pa;pa=new

int

[5];//pa指向5个未初始化的int型数据对象的首地址

delete[]pa;C++语言程序设计教程第5章构造数据类型指针变量=new类型名[下标表达式];delete[]指针变量;5.3.7指针常量与常指针

1.指针常量

指针是常量指针常量是相对于指针变量而言的，也就是指针值不能被修改的指针。如果在定义指针变量时，指针变量前用const修饰，被定义的指针变量就变成了一个指针类型的常变量，指针类型的常变量简称为指针常量。定义指针常量格式如下：

修饰符const与指针变量紧邻，说明指针变量不允许修改。既然指针变量的值不能修改，所以一定要在定义时给出初值。

数据类型*const指针名=变量名；

C++语言程序设计教程第5章构造数据类型修饰符const与指针变量紧邻，说明指针的值不允许修改，所以一定要在定义时给出初值。

inta=2;intb=3;int*constp=&a; //定义了一个指针常量并初始化

p=&b; //错误,指针常量的值为常量，不能指向其它变量

p=NULL; //错误,指针常量的值为常量，不能被修改5.3.7指针常量与常指针

因为const修饰的是指针，而不是指针指向的对象的值，所以指针指向的对象的值可以被更改：*p=4;//正确,指针常量所指变量的值可以被修改

C++语言程序设计教程第5章构造数据类型

2.常量指针常量的指针如果在定义指针变量时，数据类型前用const修饰，被定义的指针变量就是指向常量的指针变量，指向常量的指针变量简称为常量指针。定义常量指针的格式如下：

const数据类型*指针变量

=变量名；或

数据类型

const*指针变量

=变量名；定义一个常量指针后，指针指向的对象的值不能被更改，即不能通过指针来更改所指向的对象的值，但指针本身可以改变，指向另外的对象。

constinta=2;intb=3;constint*p=&a; //定义了一个常量指针并初始化

p=&b; //正确,常量指针可以指向其它变量

p=NULL; //正确,指针常量的值可以被修改5.3.7指针常量与常量指针

因为const修饰的是指针指向的值，而不是指针，所以指针指向的值不能被更改。*p=4;//错误,指针常量所指变量的值不可以被修改

const用在数组的类型前修饰数组元素，数组元素为常量的数组的称为常量数组，常量数组的元素不可改变，也不可将地址赋值给非常量指针。

constinta[3]={1,2,3}; //定义常量数组

a[0]=0;//错误,常量数组的元素不可修改

int*p=a;//错误,常量数组的地址不能赋给非常量指针C++语言程序设计教程第5章构造数据类型注意:常数组的所有元素必须全部赋初值。

constinta[]={1,2,3};//正确

constchara[]={'1','2','3'};//正确

constinta[10]={1,2,3};//错误，常数组元素没有全部赋初值

5.3.7指针常量与常指针

3.指向常量的指针常量指针常量保护指针的值不被修改，常量指针保护指针指向的值不被修改，为了将两者同时保护，可以定义指向常量的指针常量，简称为常指针常量。常指针常量是一个指向常量的指针，指针值本身也是一个常量。常指针常量定义格式如下：其中：左边的const与数据类型相结合，表明数据的值是常量；右边的const用在变量前，表明变量的值是常量。定义一个常指针常量后，修改指针的值与修改指针指向内容的值都是错误的：

constinta=2;intb=3;int*q=&b;constint*constp=&a;//定义了一个常量指针并初始化

p=&b; //错误,常指针常量的值为常量，不能指向其它变量

p=NULL;//错误,常指针常量的值为常量，不能被改变*p=b;//错误,常指针常量所指的值为常量，不能被改变

p=q; //错误,常指针常量的值为常量，不能被改变

q=p;//错误,不能将一个常指针赋给非常指针

const数据类型*const指针变量

=变量名；或

数据类型const*const指针变量=变量名；

C++语言程序设计教程第5章构造数据类型注意:常指针类型通常用作函数的形参，以防止在函数体内通过形参修改实参指向的值，以保护实参。5.4.2引用与函数

1.引用作为函数的参数

当引用作为函数的形参，在进行函数调用时，进行实参与形参的结合，其结合过程相当于定义了一个形参对实参的引用。因此，在函数体内，对形参进行运算相当于对实参进行运算。与指针相比，引用作为函数参数具有两个优点：

①

函数体的实现比指针简单。用指针作为形参，函数体内形参要带着*参加运算；而用引用作为形参，函数体内参加运算的为形参变量。②调用函数语法简单。用指针作为形参，实参需要取变量的地址；而用引用作为形参，与简单传值调用一样，实参为变量。C++语言程序设计教程第5章构造数据类型1234567891011121314151617181920

21/****************************************p5_12.cpp**用传引用的方式实现两个数交换*****************************************/#include<iostream>usingnamespacestd;voidswap(int&refx,int&refy){inttemp;temp=refx;refx=refy;refy=temp;}intmain(){intx=3,y=5;cout<<"beforeswap:x="<<x<<"y="<<y<<endl;swap(x,y);cout<<"afterswap:x="<<x<<"y="<<y<<endl;return0;}

C++语言程序设计教程第5章构造数据类型运行结果：beforeswap:x=3y=5afterswap:x=5y=35.4.2引用与函数

2.引用作为函数的返回值

函数返回值类型为引用型，在函数调用时，若接受返回值的是一个引用变量，相当于定义了一个对返回变量的引用。若接受返回值的是一个非引用变量，函数返回变量的值赋给接受变量。

如果函数返回值类型为引用型，则要求返回值为左值。这样，函数调用式可以当作左值。12345678910111213/************************************p5_13.cpp**使用引用作为函数的返回值*************************************/#include<iostream>usingnamespacestd;intmax1(inta[],intn)//求数组a[]中元素的最大值{intt=0;for(inti=0;i<n;i++)if(a[i]>a[t])t=i;returna[t]+0;}C++语言程序设计教程第5章构造数据类型1415161718192021222324252627

int&max2(inta[],intn)//求数组a[]中元素的最大值{intt=0;for(inti=0;i<n;i++)if(a[i]>a[t])t=i;returna[t];}int&sum(inta[],intn)//求数组a[]中元素的和{ints=0;for(inti=0;i<n;i++)s+=a[i];returns;}C++语言程序设计教程第5章构造数据类型5.4.2引用与函数

28293031323334353637