第六章 数组 指针与字符串

数组、指针与字符串第六章

本章主要内容数组（对象数组）指针（对象指针及指向成员的指针）指针与数组指针与函数动态内存分配浅复制与深复制字符串数组的概念数组是具有一定顺序关系的若干相同类型对象的集合体，组成数组的对象称为该数组的元素。数组属于构造类型。

数组一维数组的声明与引用一维数组的声明类型说明符数组名[常量表达式]；

例如：inta[10];

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

例如：a[0]=a[5]+a[7]-a[2*3]数组名的构成方法与一般变量名相同。数组例6.1一维数组的声明与引用#include<iostream.h>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<<"B["<<i<<"]="<<B[i]<<endl; }}一维数组的存储顺序数组元素在内存中顺次存放，它们的地址是连续的。数组名字是数组首元素的内存地址。数组名是一个常量，不能被赋值。a[0]a[1]a[2]a[3]a[4]a[5]a[6]a[7]a[8]a[9]a数组一维数组的初始化可以在编译阶段使数组得到初值：在声明数组时对数组元素赋以初值。

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

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

例如：staticinta[]={1,2,3,4,5}数组#include<iostream.h>voidmain(){inti;staticintf[20]={1,1};for(i=2;i<20;i++)f[i]=f[i-2]+f[i-1];for(i=0;i<20;i++){if(i%5==0)cout<<endl; cout.width(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列的整型数据。引用：数组名[整型表达式1][整型表达式2]…;数组存储顺序按行存放，上例中数组a的存储顺序为：

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

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

下标不要越界二维数组的声明及引用数组将所有数据写在一个{}内，按顺序赋值例如：staticinta[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};分行给二维数组赋初值例如：staticinta[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};可以对部分元素赋初值例如：staticinta[3][4]={{1},{0,6},{0,0,11}};二维数组的初始化数组数组作为函数参数数组元素作实参，与单个变量一样。数组名作参数，形参和实参都可以是数组名，类型要一样，传送的是数组首地址。对形参数组的改变会直接影响到实参数组。数组例6-2使用数组名作为函数参数在主函数中初始化一个3×4矩阵并将每个元素都输出，然后调用子函数，分别计算每一行的元素之和，将和直接存放在每行的第一个元素中，返回主函数之后输出各行元素的和。数组#include<iostream.h>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; }}voidmain(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];}运行结果：123423453456Sumofrow0is10Sumofrow1is14Sumofrow2is18101418对象数组(*)声明：类名数组名[元素个数]；访问方法：通过下标访问

数组名[下标].成员名数组对象数组的初始化数组中每一个元素对象被创建时，系统都会调用该类的构造函数初始化该对象。通过初始化列表赋值。例：

PointA[2]={Point(1,2),Point(3,4)};如果没有为数组元素指定显式初始值，数组元素便使用默认值初始化（调用默认构造函数）。数组数组元素所属类的构造函数若不声明构造函数，则采用默认构造函数。各元素对象的初值要求为相同的值时，可以声明具有默认形参值的构造函数。各元素对象的初值要求为不同的值时，需要声明带形参的构造函数。当数组中每一个对象被删除（释放）时，系统都要调用一次析构函数，析构函数的调用顺序与构造函数相反。数组例6-3对象数组应用举例//Point.h#if!defined(_POINT_H)#define_POINT_HclassPoint{public:Point();Point(intxx,intyy);~Point();voidMove(intx,inty);intGetX(){returnX;}intGetY(){returnY;}private:intX,Y;};#endif数组//point.cpp#include<iostream.h>#include"Point.h"Point::Point(){X=Y=0;cout<<"DefaultConstructorcalled."<<endl;}Point::Point(intxx,intyy){X=xx;Y=yy;cout<<"Constructorcalled."<<endl;}Point::~Point(){cout<<"Destructorcalled."<<endl;}voidPoint::Move(intx,inty){X=x;Y=y;}//6-3.cpp#include<iostream.h>#include"Point.h"voidmain(){cout<<"Enteringmain..."<<endl;Point

A[2];for(inti=0;i<2;i++)

A[i].Move(i+10,i+20);cout<<"Exitingmain..."<<endl;}运行结果：Enteringmain...DefaultConstructorcalled.DefaultConstructorcalled.Exitingmain...Destructorcalled.Destructorcalled.关于内存地址对象的访问方式通过对象名访问通过地址访问地址运算符：&例：intvar;则&var表示变量var在内存中的起始地址声明（可以声明各种类型的指针）例：inti;int*i_pointer=&i;

指向整型变量的指针指针变量的概念指针：内存地址，用于间接访问内存单元。指针变量：

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

i_pointer362000200020043010引用例1：i=3;（访问方式）例2：*i_pointer=5;

指针指针变量的初始化语法形式

存储类型数据类型*指针名＝初始地址；例：inta，*pa=&a;注意事项用变量地址作为初值时，该变量必须在指针初始化之前已说明过，且变量类型应与指针类型一致。可以用一个已赋初值的指针变量去初始化另一个指针变量。不要用一个内部auto变量去初始化static指针。指针指针变量的赋值运算指针变量名=地址“地址”中存放的数据类型与指针的类型必须相符。向指针变量赋的值必须是地址常量或变量，不能是普通整数。但可以赋值为整数0，表示空指针。指针变量的类型是它所指向变量的类型，而不是指针本身数据值的类型，任何一个指针本身的数据值都是unsignedlongint型。允许声明指向void类型的指针。该指针可以被赋予任何类型对象的地址。例：void*general;

指针例6-5指针的声明、赋值与使用#include<iostream.h>voidmain(){ int*i_pointer; inti; i_pointer=&i; i=10;

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

cout<<"Outputintpointeri="<<*i_pointer<<endl;}

指针程序运行的结果是：Outputinti=10Outputintpointeri=10例6-6void类型指针的使用voidvobject;//错，不能声明void类型的变量void*pv; //对，可以声明void类型的指针int*pint;inti;voidmain(){pv=&i; pint=(int*)pv;

}

指针指向常量的指针不能通过该指针来改变所指对象的值，但指针本身可以改变，可以指向另外的对象。例1char*name1="John";*name1='A';例2constchar*name1="John";chars[]="abc";name1=s;*name1='1';

指针指针类型的常量若声明指针常量，则指针本身的值不能被改变。例：char*constname2="John";name2="abc";指针变量的算术运算指针与整数的加减运算指针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*papb-1pbpb+1pb+2*(pb-1)*pb*(pb+1)*(pb+2)long*pb关系运算指向相同类型数据的指针之间可以进行各种关系运算。指向不同数据类型的指针，以及指针与一般整数变量之间的关系运算是无意义的。指针可以和零之间进行等于或不等于的关系运算。例如：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],*(a+i),*(pa+i),pa[i]都是等效的。不能写a++，因为a是数组首地址是常量。

指针例6-7设有一个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];}使用数组名和下标main(){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;}指针数组每个数组的元素是指针变量。声明形式： 类型名*数组名〔数组长度〕 例：Point*pa[2];

pa由pa[0],pa[1]两个指针组成指针例6-8利用指针数组存放单位矩阵#include<iostream.h>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,1例6-9二维数组举例#include<iostream.h>voidmain(){ intarray2[2][3]={{11,12,13},{21,22,23}};for(inti=0;i<2;i++){cout<<*(array2+i)<<endl; for(intj=0;j<3;j++)cout<<*(*(array2+i)+j)<<""; cout<<endl; }}

指针在某次运行之后，程序的输出结果为：0X0065FDE011,12,130X0065FDEC21,22,23以指针作为函数参数以地址方式传递数据，可以用来返回函数的处理结果。实参是数组名时形参可以是指针变量。指针与函数例6.10：读入三个浮点数，将整数部分和小数部分分别输出#include<iostream.h>voidsplitfloat(floatx,int*intpart,float*fracpart){*intpart=int(x); *fracpart=x-*intpart;}

指针与函数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; }}程序的运行结果：Enterthree(3)floatingpointnumbers4.7IntegerPartis4FractionPartis0.78.913IntegerPartis8FractionPartis0.913-4.7518IntegerPartis-4FractionPartis-0.7518例:输出数组元素的内容和地址#include<iostream.h>#include<iomanip.h>voidArray_Ptr(long*P,intn){ inti; cout<<"Infunc,addressofarrayis"

<<unsignedlong(P)<<endl; cout<<"Accessingarrayinthefunctionusingpointers"<<endl; for(i=0;i<n;i++) { cout<<"Addressforindex"<<i<<"is"

<<unsignedlong(P+i); cout<<"Valueis"<<*(P+i)<<endl; }}

指针与函数voidmain(void){ longlist[5]={50,60,70,80,90};

cout<<"Inmain,addressofarrayis"<<unsignedlong(list)<<endl; cout<<endl;

Array_Ptr(list,5);}程序的运行结果：Inmain,addressofarrayis6684132Infunc,addressofarrayis6684132AccessingarrayinthefunctionusingpointersAddressforindex0is6684132Valueis50Addressforindex1is6684136Valueis60Addressforindex2is6684140Valueis70Addressforindex3is6684144Valueis80Addressforindex4is6684148Valueis90用指向常量的指针做形参#include<iostream.h>constintN=6;voidprint(constint*p,intn);voidmain(){intarray[N];for(inti=0;i<N;i++)cin>>array[i];print(array,N);}

指针voidprint(constint*p,intn){cout<<"{"<<*p;for(inti=0;i<n;i++)cout<<"."<<*(p+i);cout<<"}"<<endl;}指针型函数

当函数的返回值是地址时，该函数就是指针型函数。声明形式：

数据类型*函数名()举例

指针与函数声明形式

数据类型(*函数指针名)(形参表);

含义：数据指针指向数据存储区，而函数指针指向的是程序代码存储区。指向函数的指针指针与函数例6-11函数指针#include<iostream.h>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);}voidprint_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;}程序运行结果：Thisistheprintstufffunction.Thisistheprintstufffunction.Thedatatobelistedis6.283180Thedatatobelistedis13.000000Thedatatobeprintedis3.141590Thedatatobeprintedis3.141590对象指针(*)声明形式类名*对象指针名；例PointA(5,10);Point*ptr;ptr=&A;通过指针访问对象成员对象指针名->成员名ptr->getx()相当于(*ptr).getx();指针对象指针应用举例intmain(){PointA(5,10);Point*ptr;ptr=&A; intx; x=ptr->getX(); cout<<x<<endl;return0;}指针this指针(1)是隐含于每一个类的成员函数中的特殊指针。明确地指出了成员函数当前所操作的数据所属的对象。当通过一个对象调用成员函数时，系统先将该对象的地址赋给this指针，然后调用成员函数，成员函数对对象的数据成员进行操作时，就隐含使用了this指针。指针this指针(2)例如：Point类的构造函数。Point::Point(intxx,intyy){X=xx;Y=yy;}相当于：this->X=xx;this->Y=yy;指针指向类的非静态成员的指针通过指向成员的指针只能访问公有成员声明指向成员的指针声明指向公有数据成员的指针类型说明符类名::*指针名；

声明指向公有函数成员的指针类型说明符(类名::*指针名)(参数表)；指针指向类的非静态成员的指针指向数据成员的指针说明指针应该指向哪个成员指针名=&类名::数据成员名；通过对象名（或对象指针）与成员指针结合来访问数据成员对象名.*类成员指针名或：对象指针名—>*类成员指针名指针

指向类的非静态成员的指针指向函数成员的指针初始化指针名=类名::函数成员名；通过对象名（或对象指针）与成员指针结合来访问函数成员(对象名.*类成员指针名)(参数表)或：(对象指针名—>*类成员指针名)(参数表)指针指向类的非静态成员的指针例6-13访问对象的公有成员函数的不同方式voidmain() { PointA(4,5); Point*p1=&A;

int(Point::*p_GetX)()=Point::GetX;

cout<<(A.*p_GetX)()<<endl;

cout<<(p1->GetX)()<<endl;

cout<<A.GetX()<<endl; }指针指向类的静态成员的指针对类的静态成员的访问不依赖于对象。可以用普通的指针来指向和访问静态成员。例6-14通过指针访问类的静态数据成员。例6-15通过指针访问类的静态函数成员。指针例6-14通过指针访问类的静态数据成员#include<iostream.h>classPoint {public:

Point(intxx=0,intyy=0){X=xx;Y=yy;countP++;}

Point(Point&p);

intGetX(){returnX;} intGetY(){returnY;}

staticintcountP;

private:

intX,Y;};Point::Point(Point&p){ X=p.X;Y=p.Y;countP++;}intPoint::countP=0; 指针voidmain() {

int*count=&Point::countP;

PointA(4,5); cout<<"PointA,"<<A.GetX()<<","<<A.GetY();

cout<<"Objectid="<<*count<<endl; PointB(A); cout<<"PointB,"<<B.GetX()<<","<<B.GetY();

cout<<"Objectid="<<*count<<endl; }例6-15通过指针访问类的静态函数成员#include<iostream.h>classPoint {public:

staticvoidGetC(){cout<<"Objectid="<<countP<<endl;}private:

intX,Y; staticintcountP; };intPoint::countP=0; 指针voidmain() {

void(*gc)()=Point::GetC; PointA(4,5); cout<<"PointA,"<<A.GetX()<<","<<A.GetY();

gc();

PointB(A); cout<<“PointB,”<<B.GetX()<<“,”<<B.GetY();

gc();}动态申请内存操作符

new(*)new

类型名T（初值列表）功能：在程序执行期间，申请用于存放T类型对象的内存空间，并以初值列表赋以初值。

结果值：

成功：T类型的指针，指向新分配的内存

失败：0（NULL）动态内存分配释放内存操作符delete(*)delete指针P功能：释放指针P所指向的内存。P必须是new操作的返回值。如果删除的是对象，该对象的析构函数被调用。

动态内存分配例6-16动态创建对象举例#include<iostream.h>classPoint{public:Point(){X=Y=0;cout<<"DefaultConstructorcalled.\n";}Point(intxx,intyy){X=xx;Y=yy;cout<<"Constructorcalled.\n";}~Point(){cout<<"Destructorcalled.\n";}intGetX(){returnX;}intGetY(){returnY;} voidMove(intx,inty) {X=x;Y=y;}private:intX,Y;};动态内存分配intmain(){cout<<"StepOne:"<<endl;

Point*Ptr1=newPoint;deletePtr1;cout<<"StepTwo:"<<endl;

Ptr1=newPoint(1,2);deletePtr1;return0;}运行结果：StepOne:DefaultConstructorcalled.Destructorcalled.StepTwo:Constructorcalled.Destructorcalled.例6-17动态创建对象数组举例#include<iostream.h>classPoint{//类的声明同例6-16，略};voidmain(){Point*Ptr=newPoint[2];

Ptr[0].Move(5,10);Ptr[1].Move(15,20);cout<<"Deleting..."<<endl;delete[]Ptr;}动态内存分配运行结果：DefaultConstructorcalled.DefaultConstructorcalled.Deleting...Destructorcalled.Destructorcalled.例6-18动态数组类#include<iostream.h>classPoint{//类的声明同例6-16…};classArrayOfPoints{private:

Point*points;

intnumberOfPoints;public:

ArrayOfPoints(intn){numberOfPoints=n;

points=newPoint[n];}~ArrayOfPoints(){cout<<"Deleting..."<<endl;numberOfPoints=0;delete[]points;}

Point&Element(intn){returnpoints[n];}};voidmain(){ intnumber; cout<<"Pleaseenterthenumberofpoints:"; cin>>number;

ArrayOfPointspoints(number);

points.Element(0).Move(5,10);

points.Element(1).Move(15,20);

}运行结果如下：Pleaseenterthenumberofpoints:2DefaultConstructorcalled.DefaultConstructorcalled.Deleting...Destructorcalled.Destructorcalled.动态创建多维数组new类型名T[下标表达式1][下标表达式2]…；如果内存申请成功，new运算返回一个指向新分配内存首地址的指针，是一个T类型的数组，数组元素的个数为除最左边一维外各维下标表达式的乘积。例如：char(*fp)[3];fp=newchar[2][3];char(*fp)[3];fp=newchar[2][3];fpfp+1fp[0][0]fp[0][1]fp[0][2]fp[1][0]fp[1][1]fp[1][2]例6-19动态创建多维数组#include<iostream.h>voidmain(){ float(*cp)[9][8]; inti,j,k; cp=newfloat[8][9][8]; for(i=0;i<8;i++) for(j=0;j<9;j++) for(k=0;k<9;k++)

(*(*(cp+i)+j)+k)=i*100+j*10+k;动态内存分配for(i=0;i<8;i++) { for(j=0;j<9;j++) {for(k=0;k<8;k++)

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

cout<<endl; } cout<<endl; }}动态内存分配函数void*malloc(size);参数size：欲分配的字节数。返回值：成功，则返回void型指针。

失败，则返回空指针。头文件：<stdlib.h>和<malloc.h>动态内存分配动态内存释放函数voidfree(void*pointer);参数pointer：指针，指向需释放的内存。返回值：无头文件：<stdlib.h>和<malloc.h>动态内存分配

浅拷贝与深拷贝(*)浅拷贝实现对象之间数据成员的一一对应复制。深拷贝当被复制的对象数据成员是指针类型时，不是复制该指针成员本身，而是将指针所指的对象进行复制。浅拷贝与深拷贝例6-20对象的浅拷贝#include<iostream.h>classPoint{//类的声明同例6-16//……};classArrayOfPoints{

//类的声明同例6-18//……};浅拷贝与深拷贝voidmain(){ intnumber; cin>>number;

ArrayOfPoints

pointsArray1(number);pointsArray1.Element(0).Move(5,10);pointsArray1.Element(1).Move(15,20);

ArrayOfPointspointsArray2(pointsArray1);cout<<"CopyofpointsArray1:"<<endl;cout<<"Point_0ofarray2:"<<pointsArray2.Element(0).GetX()<<","<<pointsArray2.Element(0).GetY()<<endl;cout<<"Point_1ofarray2:"<<pointsArray2.Element(1).GetX()<<","<<pointsArray2.Element(1).GetY()<<endl;

pointsArray1.Element(0).Move(25,30);pointsArray1.Element(1).Move(35,40);

cout<<"AfterthemovingofpointsArray1:"<<endl;cout<<"Point_0ofarray2:"<<pointsArray2.Element(0).GetX()<<","<<pointsArray2.Element(0).GetY()<<endl;cout<<"Point_1ofarray2:"<<pointsArray2.Element(1).GetX()<<","<<pointsArray2.Element(1).GetY()<<endl;}运行结果如下：Pleaseenterthenumberofpoints:2DefaultConstructorcalled.DefaultConstructorcalled.CopyofpointsArray1:Point_0ofarray2:5,10Point_1ofarray2:15,20AfterthemovingofpointsArray1:Point_0ofarray2:25,30Point_1ofarray2:35,40Deleting...Destructorcalled.Destructorcalled.Deleting...接下来程序出现异常，也就是运行错误。拷贝前拷贝后pointsArray1的数组元素占用的内存pointsnumberOfPointspointsArray1pointsnumberOfPointspointsArray1pointsArray1的数组元素占用的内存pointsnumberOfPointspointsArray2例6-21对象的深拷贝#include<iostream.h>classPoint{//类的声明同例6-16……};classArrayOfPoints{public:ArrayOfPoints(ArrayOfPoints&pointsArray);//其它成员同例6-18

};浅拷贝与深拷贝ArrayOfPoints::ArrayOfPoints(ArrayOfPoints&pointsArray){numberOfPoints=pointsArray.numberOfPoints;

points=newPoint[numberOfPoints];for(inti=0;i<numberOfPoints;i++)

points[i].Move(pointsArray.Element(i).GetX(),pointsArray.Element(i).GetY());}voidmain(){//同例6-20}程序的运行结果如下：Pleaseenterthenumberofpoints:2DefaultConstructorcalled.DefaultConstructorcalled.DefaultConstructorcalled.DefaultConstructorcalled.CopyofpointsArray1:Point_0ofarray2:5,10Point_1ofarray2:15,20AfterthemovingofpointsArray1:Point_0ofarray2:5,10Point_1ofarray2:15,20Deleting...Destructorcalled.Destructorcalled.Deleting...Destructorcalled.Destructorcalled.拷贝前pointsArray1的数组元素占用的内存pointsnumberOfPointspointsArray1拷贝后pointsnumberOfPointspointsArray1pointsArray1的数组元素占用的内存pointsnumberOfPointspointsArray2动态申请内存的另一实例如何实现两个矩阵的加法，其中矩阵的行数和列数由用户输入。解法1…………….用字符数组存储和处理字符串字符数组的声明和引用（见例6-22）例：staticcharstr[8]={112,114,111,103,114,97,109,0};

staticcharstr[8]={'p','r','o','g','r','a','m','\0'};

staticcharstr[8]="program";

staticcharstr[]="program";字符串字符串常量，例如："china"没有字符串变量，用字符数组来存放字符串字符串以‘\0’为结束标志。字符数组的初始化字符串例6-22输出一个字符串#include<iostream.h>voidmain(){staticcharc[10]={'I','','a','m','','a','','b','o','y'};inti;for(i=0;i<10;i++) cout<<c[i];cout<<endl;}运行结果：

Iamaboy字符串例6-23输出一个钻石图形#include<iostream.h>voidmain(){staticchardiamond[][5]={{'','','*'},{'','*','','*'},{'*','','','','*'},{'','*','','*'},{'','','*'}}; inti,j; for(i=0;i<5;i++) {for(j=0;j<5;j++) cout<<diamond[i][j];