c++3构造数据类型

第三章构造数据类型C++语言程序设计2本章主要内容3.1数组3.2指针指针与数组动态存储分配3.3引用3.4字符串3.5枚举类型、结构体与共用体3数组的概念n个整数的序列如何存储和处理？n=3,3个int型变量；n=10000,10000个int型变量？特点：1、相同类型的；2、数据间有顺序关系。

数组4数组的概念数组是具有一定顺序关系的若干相同类型变量的集合体，组成数组的变量称为该数组的元素。

数组5枚举型结构型联合型数组型指针型类数据类型(type)自定义类型（构造类型）基本类型布尔型bool字符型char整型int实型(浮点型)单精度型float双精度型doubleASCII6数组的概念数组是具有一定顺序关系的若干相同类型变量的集合体，组成数组的变量称为该数组的元素。

一维数组——向量arrayName[9]二维数组——矩阵arrayName[4][5]N维数组——arrayName[2][3]…[3]

数组下标数组名7一维数组的声明与使用一维数组的声明类型说明符数组名[整型常量表达式]；

例如：inta[10];

表示a为整型数组，有10个元素：a[0]...a[9]数组名的构成方法与一般变量名相同。

数组intmain(){intx=0;inta[10+x];return0;}常量表达式在编译时就可求出，值必须为正整数.errorC2057:应输入常量表达式8一维数组的声明与使用一维数组的声明类型说明符数组名[整型常量表达式]；

例如：inta[10];

表示a为整型数组，有10个元素：a[0]...a[9]数组名的构成方法与一般变量名相同。

数组数组的使用：“数组名[下标表达式]”表示数组元素，下标起始值0只能逐个引用数组元素，而不能一次引用整个数组

例如：a[0]=a[5]+a[7]-a[2*3]不要求是常量表达式，但值必须为正整数，且不能越界。9例3.1一维数组的声明与引用#include<iostream>usingnamespacestd;intmain(){inta[10],b[10];for(inti=0;i<10;i++){

a[i]=i*2-1;

b[10-i-1]=a[i];}for(inti=0;i<10;i++){cout<<"a["<<i<<"]="<<a[i]<<"";cout<<"b["<<i<<"]="<<b[i]<<endl;}return0;}

数组【注意】

“数组名[下标]”1、值为整数；2、下标值不能越界。b[9]=a[0]=-1b[8]=a[1]=1…b[0]=a[9]=17#include<iostream>usingnamespacestd;intmain(){inta[10],b[10];for(inti=0;i<10;i++){

a[i]=i*2-1;

b[10-i-1]=a[i];}for(inti=0;i<10;i++){cout<<"a["<<i<<"]="<<a[i]<<"";cout<<"b["<<i<<"]="<<b[i]<<endl;}return0;}10例3.1一维数组的声明与引用

数组【注意】数组不能越界。下标下界——0小标上界——911一维数组的存储顺序数组元素在内存中顺序、连续（地址是连续的）存储的。例如：具有10个元素的数组a，在内存中的存放次序如下（按下标从小到大以此存储）：数组名是一个常量，不能被赋值。数组名字是数组首元素的内存地址。a[0]a[1]a[2]a[3]a[4]a[5]a[6]a[7]a[8]a[9]a

数组12一维数组的初始化可以在声明数组的同时给元素赋初值：在声明数组时对全部数组元素赋以初值。

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

例如：inta[]={1,2,3,4,5}可以只给部分元素赋初值

例如：inta[10]={0,1,2,3,4};

不能间隔赋值！剩余元素默认=0

数组13例：用数组来处理求Fibonacci数列问题【费波那西数列、费氏数列、黄金分割数列】1415#include<iostream>usingnamespacestd;intmain(){intf[20]={0,1}; //初始化第0、1个数

for(inti=2;i<20;i++) //求第2～19个数

f[i]=f[i-2]+f[i-1];for(intj=0;j<20;j++){ //输出，每行5个数

if(j%5==0)cout<<endl; cout.width(12); //设置输出宽度为12 cout<<f[j];}return0;}例：用数组来处理求Fibonacci数列问题【费波那西数列、费氏数列、黄金分割数列】16例：用数组来处理求Fibonacci数列问题运行结果：

0

1 1 2 3 5

8 13 21 34

55 89 144 233 377 610

987 1597 2584 4181 17一维数组应用举例循环从键盘读入若干组选择题答案，计算并输出每组答案的正确率，直到输入ctrl+z为止。每组连续输入5个答案，每个答案可以是'a'..'d'。

数组ctrl+z的作用是输入一个终止符"^Z"，终止符的作用就是终止当前的命令.#include<iostream>usingnamespacestd;intmain(){constchar

KEY[]={'a','c','b','a','d'};constintNUM_QUES=5;

charc;

int

ques=0,numCorrect=0;

cout<<"Enterthe"<<NUM_QUES<<"questiontests:"<<endl;

while(cin.get(c)){if(c!='\n'){

if(c==KEY[ques]){

numCorrect++;

cout<<"";}

else

cout<<"*";

ques++;}

else{cout<<"Score"<<float(numCorrect)/NUM_QUES*100<<"%";

ques=0;

numCorrect=0;

cout<<endl;}}return0;}18//数组声明为常量，保存答案运行结果：acbba**

Score

60%acbadScore100%abbda***Score40%bdcba*****Score0%19constcharKEY[]={'a','c','b','a','d'};20二维数组的声明及引用数据类型标识符[常量表达式1][常量表达式2];例:inta[5][3];

表示a为整型二维数组，

其中第一维有5个下标（0~4）

第二维有3个下标（0~2）

数组的元素个数为5*3=15可以用于存放5行3列的整型数据矩阵。

数组行标列标21存储顺序按行存放，上例中数组a的存储顺序为：

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

a[2]——a20a21a22a23a可以理解为：引用例如：b[1][2]=a[2][3]/2下标不要越界二维数组的声明及引用

数组22将所有数据写在一个{}内，按顺序赋值例如：给出全部元素时，第一维下标个数可省略inta[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};inta[][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}};二维数组的初始化

数组二维数组声明、初始化和使用#include<iostream>usingnamespacestd;intmain(){inta[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};for(inti=0;i<3;i++){ for(intj=0;j<4;j++) cout<<a[i][j]<<'\t'; cout<<endl;}return0;}2324枚举型结构型联合型数组型指针型类数据类型(type)自定义类型（构造类型）基本类型布尔型bool字符型char整型int实型(浮点型)单精度型float双精度型doubleASCII25内存地址：理解C++指针的基础内存储器以字节为基本存储单元，进行编号——内存地址。内存空间的访问方式通过变量名访问：存取变量内容通过地址访问：没有变量名或不方便使用变量名（如，程序运行时，动态创建数组）

指针26内存地址：理解C++指针的基础取地址运算符：&例：intvar;则&var

表示变量var在内存中的起始地址#include<iostream>usingnamespacestd;intmain(){ inti=0; cout<<&i<<endl; return0;}

指针27声明：

数据类型*标识符；

概念

指针：内存地址，用于

间接访问内存单元

指针变量：

用于存放内存地址

指针指针的概念32位计算机，地址长度32位。指针本身的数据值都是unsignedlongint型。声明指针时需要明确指出它用于存放什么类型数据的地址。28定义：

数据类型*标识符；如：inti=3,j=6;int*ptr;ptr=&i;

概念

指针：内存地址，用于

间接访问内存单元

指针变量：

用于存放内存地址内存用户数据区变量i变量j变量

ptr362000200020043010

指针指针的概念32位计算机，地址长度32位。指针本身的数据值都是unsignedlongint型。29语法形式

数据类型*指针名＝初始地址；

指针名=地址;注意事项用&取变量地址作为初值时，该变量必须在指针初始化之前已声明过，且变量类型应与指针类型一致。可以用一个已赋初值的指针变量去初始化另一个指针变量。

指针指针的定义、赋值与使用30inta,b;int*pa,*pb=&b,*ppa;pa=&a;ppa=pa;*

声明指针变量&

取地址运算符：获取变量内存中的起始地址可以用一个已赋初值的指针去初始化另一个指针变量。多个指针指向同一个变量。指针的定义、赋值与使用31*声明指针变量int*ptr;指针运算符：访问指针所指向变量的内容。*ptr=3;&声明引用(3.3节)：int&k=i;取地址运算符：cout<<&i<<endl;获取变量内存中的起始地址指针的定义、赋值与使用32指针的定义、赋值与使用#include<iostream>usingnamespacestd;intmain(){ inti=10; //定义int型数i int*ptr=&i; //取i的地址赋给ptr//输出int型数的值

cout<<"i="<<i<<endl;

//输出int型指针所指地址的内容

cout<<"*ptr="<<*ptr<<endl;

return0;}

指针300010ptr*ptri3000【*指针(间接)运算符】：访问指针（变量）所指向的变量inti;int*ptr=&i;*ptr=1033【*指针(间接)运算符】：访问指针（变量）所指向的变量内容。ptr*ptri3000指针的定义、赋值与使用10300034指向”常量”的指针不能通过指针来改变所指对象的值，但指针本身可以改变，可以指向另外的对象。例inta;constint*p1=&a; //p1是指向”常量”的指针intb;p1=&b; //正确，p1本身的值可以改变*p1=1; //编译时出错，不能通过p1改变所指的对象

指针errorC3892:“p1”:不能给常量赋值35指针类型的常量若声明指针常量，则指针本身的值不能被改变，声明时指定初始化地址。例：inta,b;int*constp2=&a;p2=&b;//错误，p2是指针常量，值不能改变

指针36指针的各种运算指针是一种数据类型，指针变量可以参与部分运算算术运算关系运算赋值运算

指针37指针变量的算术运算指针与整数的加减运算指针p加上或减去n，其意义是指针当前指向位置的前方或后方第n个数据的地址。这种运算的结果值取决于指针指向的数据类型。*(p+n)等价于p[n]指针加一，减一运算指向下一个或前一个数据。例如：y=*px++

相当于y=*(px++)

(*和++优先级相同，自右向左运算)

指针papa-2pa-1pa+1pa+2pa+3*(pa-2)或pa[-2]*pa或pa[0]*(pa+1)或pa[1]*(pa+2)或pa[2]*(pa+3)或pa[3]*(pa-1)或pa[-1]short*pa38指针p加上n——指针当前指向位置的前方第n个数据的地址。指针p减去n——指针当前指向位置后方第n个数据的地址。指向short类型的指针，每次移动2个字节连续内存空间中的同类数据pb-1pbpb+1pb+2*(pb-1)或pb[-1]*pb或pb[0]*(pb+1)或pb[1]*(pb+2)或pb[2]long*pb39指向long类型的指针，每次移动4个字节连续内存空间中的同类数据40指针变量的算术运算指针与整数的加减运算指针p加上或减去n，其意义是指针当前指向位置的前方或后方第n个数据的地址。*(p1+n1)等价于p1[n1]指针加一，减一运算指向下一个或前一个数据。

指针指针的算术运算和数组的使用相关（适合处理连续内存空间中的同类数据）41指针与数组的关系inta[10];int*ptr=a;数组名表示的数组首地址来初始化化指针。数组名是一个指针常量，不能被赋值。数组名字是数组首元素的内存地址。a[0]a[1]a[2]a[3]a[4]a[5]a[6]a[7]a[8]a[9]aptrint*ptr=&a[0]42用指针处理数组元素声明与赋值例：shorta[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是数组首地址是指针常量。

指针43用指针处理数组元素数组名是一个指针常量，不能被赋值。数组名字是数组首元素的内存地址。a[0]a[1]a[2]a[3]a[4]a[5]a[6]a[7]a[8]a[9]a*(pa+1）*(a+1)*pa*(pa+6）*(a+6)a[i],*(a+i),*(pa+i),pa[i]都是等效的pa=&a[0];或pa=a44例设有一个int型数组a，有10个元素。用三种方法输出各元素：1、使用数组名和下标2、使用数组名和指针运算3、使用指针变量

指针#include<iostream>usingnamespacestd;intmain(){ inta[10]={1,2,3,4,5,6,7,8,9,0}; for(inti=0;i<10;i++) cout<<a[i]<<""; cout<<endl; return0;}1、使用数组名和下标45a[i],*(a+i),*(pa+i),pa[i]都是等效的#include<iostream>usingnamespacestd;intmain(){ inta[10]={1,2,3,4,5,6,7,8,9,0}; for(inti=0;i<10;i++) cout<<*(a+i)<<""; cout<<endl; return0;}2、使用数组名指针运算46a[i],*(a+i),*(pa+i),pa[i]都是等效的3、使用指针变量#include<iostream>usingnamespacestd;intmain(){ inta[10]={1,2,3,4,5,6,7,8,9,0};

int*pa=a; for(inti=0;i<10;i++) cout<<pa[i]<<""; cout<<endl; return0;}47a[i],*(a+i),*(pa+i),pa[i]都是等效的3、使用指针变量#include<iostream>usingnamespacestd;intmain(){ inta[10]={1,2,3,4,5,6,7,8,9,0}; for(int

*p=a;p<(a+10);p++) cout<<*p<<""; cout<<endl; return0;}48a[i],*(a+i),*(pa+i),pa[i]都是等效的不能写a++，因为a是数组首地址是常量49关系运算指向相同类型数据的指针之间可以进行各种关系运算。相等——指向同一个地址。指针可以和零之间进行等于或不等于的关系运算。p==0或p!=00，表示空指针，NULL以下关系运算是无意义的：指向不同数据类型的指针指针与非0整数变量之间。指针变量的关系运算

指针50赋值运算向指针变量赋的值必须是:类型要一致1、&变量2、数组名3、指针变量4、整数0，表示空指针，NULL，不指向任何地址int*p=NULL;没有明确的地址值可以赋值时，为了防止出现不可预见的错误，将指针设置为NULL。不能是非0的整数。指针变量的赋值运算

指针51指针数组数组的元素是同一类型的指针。数据类型*数组名[整型常量表达式];例：int*pa[2];

由pa[0],pa[1]两个指针组成

指针52例

利用指针数组存放单位矩阵#include<iostream>usingnamespacestd;intmain(){ intline1[]={1,0,0}; //矩阵的第一行

intline2[]={0,1,0}; //矩阵的第二行

intline3[]={0,0,1}; //矩阵的第三行……

//定义整型指针数组并初始化,指向一行

int*pLine[3]={line1,line2,line3};

指针pLine[0]=line1pLine[1]=line2pLine[2]=line3531pLine[0]pLine[1]pLine[2]00010001Line1Line2Line3例

利用指针数组存放单位矩阵pLine*(pLine[0]+j)*(pLine[1]+j)*(pLine[2]+j)pLine[0][j]pLine[1][j]pLine[2][j]*(line1+j)、line1[j]等效;*(line2+j)、line2[j]等效;*(line3+j)、line3[j]等效; cout<<"Matrixtest:"<<endl;//输出单位矩阵

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

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

cout<<*(pLine[i]+j)<<"";cout<<endl; } return0;}输出结果为：Matrixtest:1,0,00,1,00,0,154pLine[0][j]、*(pLine[0]+j)、*(line1+j)、line1[j]等效;pLine[1][j]、*(pLine[1]+j)、*(line2+j)、line2[j]等效;pLine[2][j]、*(pLine[2]+j)、*(line3+j)、line3[j]等效;pa[i],*(pa+i),*(a+i),a[i]都是等效的 cout<<"Matrixtest:"<<endl;//输出单位矩阵

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

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

cout<<pLine[i][j]<<"";cout<<endl; } return0;}输出结果为：Matrixtest:1,0,00,1,00,0,155pLine[0][j]、*(pLine[0]+j)、*(line1+j)、line1[j]等效;pLine[1][j]、*(pLine[1]+j)、*(line2+j)、line2[j]等效;pLine[2][j]、*(pLine[2]+j)、*(line3+j)、line3[j]等效;pa[i],*(pa+i),*(a+i),a[i]都是等效的56例

二维数组举例#include<iostream>usingnamespacestd;intmain(){intarray2[3][3]={{11,12,13},{21,22,23},{31,32,33}};for(inti=0;i<3;i++){for(intj=0;j<3;j++)cout<<array2[i][j]<<""; //逐个输出二维数组第i行元素值

cout<<endl;}return0;}

指针指针数组vs二维数组57111213212223313233array2for(inti=0;i<3;i++){for(intj=0;j<3;j++)cout<<array2[i][j]<<""; cout<<endl;} array2[0][0]array2[1][0]array2[2][0]指针数组vs二维数组58array2[0]array2[1]array2[2]111213212223313233array2int*array2[3];

array2[0][0]array2[1][0]array2[2][0]*(array2+i)、array2[i]等效指针数组vs二维数组59array2[0]array2[1]array2[2]111213212223313233array2array2[i][j]、*(array2[i]+j)等效int*array2[3];

array2[0][0]array2[1][0]array2[2][0]60#include<iostream>usingnamespacestd;intmain(){intarray2[3][3]={{11,12,13},{21,22,23},{31,32,33}};for(inti=0;i<3;i++){for(intj=0;j<3;j++)cout<<*(array2[i]+j)<<""; //逐个输出二维数组第i行元素值

cout<<endl;}return0;}

指针*(array2[i]+i)、array2[i][j]等效*(array2+i)、array2[i]等效61#include<iostream>usingnamespacestd;intmain(){intarray2[3][3]={{11,12,13},{21,22,23},{31,32,33}};for(inti=0;i<3;i++){for(intj=0;j<3;j++)cout<<*(*(array2+i)+j)<<""; //逐个输出二维数组第i行元素值

cout<<endl;}return0;}

指针*(array2[i]+i)、array2[i][j]等效*(array2+i)、array2[i]等效程序的输出结果为：1112132122233132336263动态内存分配n个整数的序列如何存储和处理？n=？动态存储分配程序运行前，并不能确切地知道数组中会有多少个元素。c++中，动态内存分配技术保证程序在运行过程中按照实际需要申请适量的内存，使用结束后还可以释放。64动态申请内存操作符newnew类型名T（初始化参数）功能：在程序执行期间，申请用于存放T类型对象的内存空间，并依初值列表赋以初值。

int*point=newint(2);结果值：成功：T类型的指针，指向新分配的内存；失败：抛出异常。

动态存储分配65动态申请内存操作符newnew类型名T（初始化参数）int*point=newint(2);int*point=newint();//初始化为0int*point=newint;//无初值,随机数

动态存储分配66释放内存操作符deletedelete指针p功能：释放指针p所指向的内存。

p必须是new操作的返回值。int*point=newint(2);……deletepoint;

动态存储分配申请和释放动态一维数组分配：new类型名T[数组长度]

数组长度可以是任何得到正整数的表达式，在运行时计算，返回数组首地址。释放：delete[]

数组名p释放指针p所指向的数组。p必须是用new分配得到的数组首地址。//初始化为0int*p=newint[6]();delete[]p;67int*p;p=newint[6];pp+3p[0]p[1]p[2]p[3]p[4]p[5]68int类型的指针*(p+3)*(p+1)p[i]<=>*(p+i)p+1*(p)69动态创建多维数组new类型名T[第1维长度][第2维长度]…；如果内存申请成功，new运算返回一个指向新分配内存首地址的指针

char(*fp)[3];//一维char类型数组的指针fp=newchar[2][3];

动态存储分配【正整数表达式】【正整数常量表达式】2个元素的一维数组每个元素都是char[3]T类型数组的指针指针数组.VS.数组指针

--------------指针数组-----------------

char*p[6];//指针数组

含有6个指针元素，每一个元素都是char指针

70--------------指针数组-----------------

char*p[6];含有6个指针元素，每一个元素都是char指针p[0]p[1]p[2]p[3]p[4]p[5]71pchar类型的指针指针数组.VS.数组指针

--------------指针数组-----------------

char*p[6];//指针数组

含有6个指针元素，每一个元素都是char指针

--------------数组指针(P74)------------

//含6个char元素一维数组的指针

char(*p)[6];

chara[6];p=&a;

72int(*fp)[3];inta[2][3];fp=a(或&a[0]);a[0]a[1]a[0][0]a[0][1]a[0][2]a[1][0]a[1][1]a[1][2]73*(*(fp+1)+1)*(*(fp+0)+0)fp[i][j]<=>*(*(fp+i)+j)fp*(*(fp+0)+2)*(fp+1)2个元素的一维数组，每个元素都是int[3]aint(*fp)[3];fp=newint[2][3];fp[0]fp[1]fp[0][0]fp[0][1]fp[0][2]fp[1][0]fp[1][1]fp[1][2]74int类型一维数组的指针,数组长度3*(*(fp+1)+1)*(*(fp+0)+0)fp[i][j]<=>*(*(fp+i)+j)fp*(*(fp+0)+2)*(fp+1)2个int[3]75例,动态创建多维数组#include<iostream>usingnamespacestd;intmain(){float(*cp)[9][8]=newfloat[8][9][8];for(inti=0;i<8;i++)for(intj=0;j<9;j++)for(intk=0;k<8;k++)//以指针形式数组元素*(*(*(cp+i)+j)+k)=(float)(i*100+j*10+k);

动态存储分配8个float[9][8]*(cp+i)第i个float[9][8] for(inti=0;i<8;i++){ for(intj=0;j<9;j++){ for(intk=0;k<8;k++)

cout<<cp[i][j][k]<<""; cout<<endl; } cout<<endl; }

delete[]cp; return0;}76将指针cp作为数组名使用，通过数组名和下标访问数组元素77例,动态创建多维数组int*p[3];for(inti=0;i<3;i++){

intcount=2*i+1;

p[i]=newint[count];

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

{

p[i][j]=j+1;

}}

动态存储分配78p[0]p[1]pp[2]p00p10p11p12p20p21p22p23p24int*p[3];for(inti=0;i<3;i++){ intcount=2*i+1;

p[i]=newint[count]; for(intj=0;j<count;j++){ p[i][j]=j+1; }}79引用的概念引用引用（reference）已经存在的变量的别名。与变量占用同一块存储空间。类型名&别名=目标变量名;80引用的概念引用#include<iostream>usingnamespacestd;intmain(){intv=1;

int&rv=v; //定义rv是变量v的别名cout<<"v="<<v<<"\t"<<"rv="<<rv<<endl;

rv=2;

//相当于r=2cout<<"v="<<v<<"\t"<<"rv="<<rv<<endl;//输出v和引用rv的地址cout<<"&v="<<&v<<"\t"<<"&rv="<<&rv<<endl;return0;}81引用的概念引用引用（reference）已经存在的变量的别名。与变量占用同一块存储空间。【说明】1、表达式和常量不能定义别名。2、引用必须初始化，“从一而终”。3、变量的引用不会分配存储空间。类型名&别名=目标变量名;82引用的概念引用//引用必须初始化，“从一而终”#include<iostream>usingnamespacestd;intmain(){ intx=1,y=2;

int&r=x; r=y; //相当于x=y;

int&r=y; return0;}83引用的概念引用数组的引用（reference）类型名

（&别名）[..]

=目标数组名;#include<iostream>usingnamespacestd;intmain(){ inta[5]={1,2,3,4,5};

//()不能少,

元素个数必须与数组a的一致 int(&ra)[5]=a;

for(inti=0;i<5;i++) cout<<ra[i]<<"\t"; cout<<endl;

return0;}指针数组.VS.数组指针

--------------数组的引用---------------

//()不能少,元素个数必须与数组a的一致int(&ra)[5]=a;

ra[i]<==>a[i]

--------------数组指针(P74)------------

//含6个int元素一维数组的指针

char(*p)[6];

chara[6];p=&a;

84char(*p)[6];//数组指针,6个元素的int数组chara[6];p=&a;int(&ra)[5]=a;a[0]a[1]a[2]a[3]a[4]a[5]85pa*(*(p)+1)*(*(p)+0)*(p)*(*(p)+3)a别名ra86引用与指针的区别引用1、引用必须初始化，且“从一而终”；2、指针可以从指向一个变量，转到指向另一个变量。指向不确定是，可以设置为空指针NULL。用字符数组存储和处理字符串字符数组的定义:字符数组的初始化:87

字符串1、逐一赋值charstr[8]={'p','r','o','g','r','a','m','\0'};charstr[8]={'p','r','o','g','r','a','m'};2、字符串常量赋值charstr[8]={"program"};charstr[8]="program";charstr[]="program";char字符数组名[整型常量表达式];用字符数组存储和处理字符串字符数组的定义:字符数组的初始化:88

字符串char字符数组名[整型常量表达式];#include<iostream>usingnamespacestd;intmain(){ charstr[8]="司马相如"; return0;}用字符数组存储和处理字符串字符数组的赋值与引用:89

字符串chars[5];s={'C','+','+'}; //不能对整个数组赋值s={"C++"}; //不能对整个数组赋值s="C++";

//不能对整个数组赋值//只能对数组元素赋值s[0]='C';s[1]='+';s[2]='+';只能对数组元素赋值不能对整个数组赋值用字符数组存储和处理字符串字符数组的赋值与引用:90

字符串 chars[5]; s={'C','+','+'}; //不能对整个数组赋值 s={"C++"}; //不能对整个数组赋值 s="C++";

//不能对整个数组赋值 //只能对数组元素赋值 s[0]='C';s[1]='+';s[2]='+';只能对数组元素赋值不能对整个数组赋值用字符数组存储和处理字符串字符数组的输入与输出:91

字符串1、逐个字符输入输出，与普通数组一样.用字符数组存储和处理字符串字符数组的输入与输出:92

字符串2、利用cin或cout将整个字符串一次性输入或输出.#include<iostream>usingnamespacestd;intmain(){ charname[10]; cin>>name; cout<<"Name="<<name<<endl; return0;}//数组名//键盘输入的字符串应短于字符数组长度//空格、回车、Tab键作为结束标志用字符数组存储和处理字符串字符数组的输入与输出:93

字符串3、通过getline输入一整行内容.cin.getline(字符数组名,数组长度,结束字符)其中，“结束字符”缺省为'\n'#include<iostream>usingnamespacestd;intmain(){ chars[10];

//输入字符个数超过7或者遇到字符'.' cin.getline(s,7,'.'); cout<<s<<endl; return0;}用字符数组存储和处理字符串字符指针的定义:94

字符串1、指向字符串常量char*p

="program";2、

指向字符数组chars[20]={“IloveC++"};

char*p;p

=s;3、指向动态创建的字符数组

char*p

=newchar[20];char*字符指针名;字符数组.VS.字符指针

----------------字符数组-----------------

1、存放全部字符；

----------------字符指针-----------------

1、存放存储字符串的区域的首地址;

95#include<iostream>usingnamespacestd;intmain(){ chars[20]="C++程序设计"; char*p=s; cout<<"sizeof(s)="<<sizeof(s)<<endl; cout<<"sizeof(p)="<<sizeof(p)<<endl; cout<<"strlen(s)="<<strlen(s)<<endl; cout<<"strlen(p)="<<strlen(p)<<endl; return0;}用字符数组表示字符串的缺点用字符数组表示字符串的缺点执行连接、拷贝、比较等操作，都需要显式调用库函数，很麻烦.当字符串长度很不确定时，需要用new动态创建字符数组，最后要用delete释放，很繁琐.字符串实际长度大于为它分配的空间时，会产生数组下标越界的错误.解决方法使用字符串类string表示字符串.string实际上是对字符数组操作的封装.96

字符串string的定义//包含C++标准库中的string头文件#include<string>

//建立一个空字符串strings1;

//字符串初始化strings2=“C++Language";

97

字符串string的长度和内存大小98

字符串#include<iostream>#include<string>usingnamespacestd;intmain(){ strings="abcde"; cout<<"s.length()="<<s.length()<<endl; cout<<"sizeof(s)="<<sizeof(s)<<endl; return0;}string的赋值99

字符串1、赋予一个字符串常量

strings1="program";2、用string变量赋值

strings2; s2=s1;3、对string变量中的某一个字符进行操作 stringword="man"; word[1]='e';string变量的运算常用操作符s+t

将串s和t连接成一个新串s=t

用t更新s,t——字符串常量、string对象，字符数组s==t

判断s与t是否相等s!=t

判断s与t是否不等s<t

判断s是否小于t（按字典顺序比较）s<=t

判断s是否小于或等于t（按字典顺序比较）s>t

判断s是否大于t（按字典顺序比较）s>=t

判断s是否大于或等于t（按字典顺序比较）s[i]

访问串中下标为i的字符例：strings1=“abc”,s2=“def”;strings3=s1+s2; //结果是”abcdef”boolb=(s1<s2); //结果是truechara=s2[1]; //结果是’e’100

字符串101例string类应用举例#include<string>#include<iostream>usingnamespacestd;intmain(){ ……}

字符串intmain(){ strings1="DEF";

cout<<"s1is"<<s1<<endl; strings2; cout<<"Pleaseenters2:";

cin>>s2; cout<<"lengthofs2:"<<s2.length()<<endl; //比较运算符的测试

if(s1<="ABC") cout<<"s1<=\"ABC\""<<endl; else cout<<"s1>\"ABC\""<<endl; //连接运算符的测试

s2+=s1; cout<<"s2=s2+s1:"<<s2<<endl; cout<<"lengthofs2:"<<s2.length()<<endl; return0;}102用getline输入整行字符串输入整行字符串用cin的>>操作符输入字符串，会以空格作为分隔符，空格后的内容会在下一回输入时被读取；用string头文件中的getline可以输入整行字符串，例如：getline(cin,s2);103

字符串用getline输入整行字符串以其它字符作为分隔符输入字符串输入字符串时，可以使用其它分隔符作为字符串结束的标志（例如逗号、分号）把分隔符作为getline的第3个参数即可getline(cin,s2,',');104

字符串例

用getline输入字符串105include<iostream>#include<string>usingnamespacestd;intmain(){ for(inti=0;i<2;i++) { stringcity,state;

getline(cin,city,',');

getline(cin,state); cout<<"City:"<<city<<“State:"<<state<<endl; } return0;}

字符串Beijing,ChinaCity:BeijingState:ChinaSanFrancisco,theUnitedStatesCity:SanFranciscoState:theUnitedStatesstring数组106

字符串#include<string>#include<iostream>usingnamespacestd;intmain(){

stringBookName[3]={ "三国演义", "红楼梦", "射雕英雄传" }; for(inti=0;i<3;i++) cout<<BookName[i]<<endl; return0;}107枚举类型—enum数据只有有限的几种可能取值：一个星期：星期一、星期二、…、星期日性别：男、女学历：专科、本科、硕士、博士可以用int、char等基本数据类型来表示，但需要进行合法性检查如，0-男、1-女、2-表示什么？？自定义数据类型108枚举类型—enum枚举类型的声明形式如下：enum枚举类型名{变量值列表};只要将需要的变量值一一列举出来，便构成了一个枚举类型。例如：enumWeekday{SUN,MON,TUE,WED,THU,FRI,SAT};自定义数据类型枚举元素109枚举类型—enum枚举类型应用说明：对枚举元素按常量处理，不能对它们赋值。例如，不能写：SUN=0;

枚举元素具有缺省值，它们依次为：0,1,2,......。也可以在声明时另行指定枚举元素的值，如：enumweekday{sun=7,mon=1,tue,wed,thu,fri,sat};枚举值可以进行关系运算。

整数值不能直接赋给枚举变量，如需

要将整数赋值给枚举变量，应进行强

制类型转换。自定义数据类型110例设某次体育比赛的结果有四种可能：胜（win）、负（lose）、平局（tie）、比赛取消（cancel），编写程序顺序输出这四种情况。分析：由于比赛结果只有四种可能，所以可以声明一个枚举类型，声明一个枚举类型的变量来存放比赛结果。自定义数据类型#include<iostream>usingnamespacestd;enumgame_result{WIN,LOSE,TIE,CANCEL};voidmain(){

game_resultresult;

enumgame_resultomit=CANCEL;intcount;for(count=WIN;count<=CANCEL