面向对象程序设计A总结

面向对象

程序设计A主讲：张冀E-mail:ijgnahz123@163.comTel学与统计学院*第一章绪论3不同进位记数制间的转换

——R进制→十进制各位数字与它的权相乘，其积相加。例如:(11111111.11)2=1×27+1×26+1×25+1×24

+1×23+1×22+1×21+1×20+1×2-1+1×2-2

=(255.75)10(3506.2)8=3×83+5×82+0×81+6×80+2×8-1

=(1862.25)10(0.2A)16=2×16-1+10×16-2=(0.1640625)10信息的表示与存储4不同进位记数制间的转换

——十进制→R进制十进制整数转换成R进制的整数“除R取余”法，例如：268余数

234┄┄┄┄┄┄┄┄┄┄┄0低位

217┄┄┄┄┄┄┄┄┄┄┄028┄┄┄┄┄┄┄┄┄┄┄124┄┄┄┄┄┄┄┄┄┄022┄┄┄┄┄┄┄┄┄┄021┄┄┄┄┄┄┄┄┄00┄┄┄┄┄┄┄┄┄1高位所以6810＝10001002信息的表示与存储5不同进位记数制间的转换

——十进制→R进制十进制小数转换成R进制小数“乘R取整”法，例如：高位

0.3125×2=0.6250.625×2=1.250.25×2=0.50.5×2=1.0所以0.312510=0.01012

信息的表示与存储6不同进位记数制间的转换

——二、八、十六进制的相互转换每位八进制数相当于三位二进制数每位十六进制数相当于四位二进制数(1011010.10)2=(001

011

010.100)2

=(132.4)8(1011010.10)2=(0101

1010.1000)2

=(5A.8)16(F7)16＝(1111

0111)2＝(11110111)2信息的表示与存储7二进制数的编码表示:补码计算机中的补码表示法负数的补码由该数反码的末位加1求得对补码再求补即得到原码补码运算规则符号位可作为数值参加运算减法运算可转换为加法运算：加上一个负数等于加上该数的补码补码运算的结果仍为补码运算结果溢出：负数之和得正数，或正数之和得负数（-32）10=（11100000）2=（E0）16信息的表示与存储8程序的开发过程编辑将源程序输入到计算机中，生成后缀为cpp的磁盘文件。编译将程序的源代码转换为机器语言代码。连接将多个源程序文件以及库中的某些文件连在一起，生成一个后缀为exe的可执行文件。运行调试程序的开发过程10本章主要内容C++语言概述基本数据类型和表达式数据的输入与输出算法的基本控制结构自定义数据类型11数据类型

—整型数据及取值范围类型 说明符 位数 数值范围 短整

short 16 -32768～32767基本

int 32 -231～(231-1)长整

long 32 -231～(231-1)无符号unsignedshort 16 0～65535unsigned

int 32 0～(232-1)unsignedlong 32 0～(232-1) 基本数据类型和表达式12#include<iostream>usingnamespacestd;intmain(){constintPRICE=30;

int

num,total;floatv,r,h;num=10;total=num*PRICE;

cout<<total<<endl;

r=2.5;h=3.2;v=3.14159*r*r*h;

cout<<v<<endl;}

数据类型

——实型数据实型常量float4字节精度：3.4×10±387位有效数字double8字节精度：1.7×10±30815位有效数字longdouble8字节精度：1.7×10±30815位有效数字实型变量默认为double型后缀F（或f）

为float型后缀L（或l）

为longdouble

型基本数据类型和表达式13

数据类型

——字符型数据（一）字符常量单引号括起来的一个字符，

如：'a','D','?','$'字符变量用来存放字符常量

例：charc1,c2;

c1='a';

c2='A';字符数据在内存中的存储形式以ASCII码存储，占1字节，用7个二进制位基本数据类型和表达式14字符数据的使用方法字符数据和整型数据之间可以运算。字符数据与整型数据可以互相赋值。字符串常量例:"CHINA"

"a"

'a'所以：charc;

c="a";CHINA\0a

\0aPage14

数据类型

——字符型数据（二）基本数据类型和表达式15

数据类型

——布尔型数据布尔型变量的说明：

例：boolflag;布尔型数据的取值：

只有false

和true

两个值基本数据类型和表达式16

数据类型

——常量与变量#include<iostream>usingnamespacestd;intmain(){

constintPRICE=30;

int

num,total;floatv,r,h;

num=10;total=num*PRICE;

cout<<total<<endl;r=2.5;h=3.2;v=3.14159*r*r*h;

cout<<v<<endl;}常量变量变量先声明后使用符号常量基本数据类型和表达式17

数据类型

——变量初始化例：

inta=3;

doublef=3.56;

charc='a';

intc(5);Page17基本数据类型和表达式181、算数运算符与表达式2、赋值运算符与赋值表达式3、逗号运算和逗号表达式4、逻辑运算与逻辑表达式5、条件运算符与条件表达式6、sizeof运算符7、位运算8、运算符优先级与结合性9、混合运算时数据类型的转换Page18基本数据类型和表达式运算符与表达式19运算符优先级++，--，sizeof*,/,%+,-==,!=位运算&&||?:赋值运算逗号运算低高基本数据类型和表达式20简单的输入、输出向标准输出设备（显示器）输出例：intx;

cout<<"x="<<x;从标准输入设备（键盘）输入例：intx;

cin>>x;21顺序结构分支结构（if、switch）循环结构（while、dowhile、for）算法的基本控制结构22一般形式switch(表达式){case常量表达式1：语句1case常量表达式2：语句2┆case常量表达式n：语句ndefault:语句n+1}switch语句执行顺序以case中的常量表达式值为入口标号，由此开始顺序执行。因此，每个case分支最后应该加break语句。每个常量表达式的值不能相同，次序不影响执行结果。可以是多个语句，但不必用{}。可以是整型、字符型、枚举型算法的基本控制结构23while语句形式while(表达式)语句

可以是复合语句，其中必须含有改变条件表达式值的语句。执行顺序先判断表达式的值，若为true时，执行语句。算法的基本控制结构24do-while语句一般形式do语句while(表达式)可以是复合语句，其中必须含有改变条件表达式值的语句。执行顺序先执行循环体语句，后判断条件。

表达式为true时，继续执行循环体与while语句的比较：While语句执行顺序

先判断表达式的值，为true时，再执行语句算法的基本控制结构25for语句语法形式for(表达式1；表达式2；表达式3)语句

循环前先求解为true时执行循环体每次执行完循环体后求解算法的基本控制结构26枚举类型—enum只要将需要的变量值一一列举出来，便构成了一个枚举类型。枚举类型的声明形式如下：enum

枚举类型名{变量值列表};例如：enumweekday{sun,mon,tue,wed,thu,fri,sat};自定义数据类型例题1：运算符+、=、*、>=中，优先级最高的运算符是（

）。A．+B．=C．*D．>=例题2：下列说法正确的是（

）。A．cout<<”\n”是一个语句，它能在屏幕上显示”\n”B．\68代表的是字符D。C．1E+5的写法正确，它表示余割整型常量。D．0x10相当于020。D根据C++语言对运算符优先级的规则，以上运算符优先级从低到高的次序为=、>=、+、*。C分号是语句的已部分，且\n是转义字符；\68代表了八进制的6、8，而八进制中没有数字8；1E+5是实型常量；十六进制的10相当于十进制的16，相当于八进制的20。例题3：下列不合法的变量名为（

）。A．intB．int1C．name_1D．Name0例题4：已知a=4，b=6，c=8，d=9，则“（a++，b>a++&&c>d）？++d：a<b”值为（

）。A．9B．6C．8D．0填空题例题5：如果s是int型变量，且s=6，则下面s%2+（s+1）%2表达式的值为____。课后:2-23、2-24*A根据变量名命名要求，变量名只能由大小写字母、数字、下划线组成，且系统关键字不能作为变量名。D1%运算符是求余运算，得到的结果是相除后的余数。表达式转换为6%2+（6+1）%2=0+7%2=1第三章函数面向对象程序设计A30本章主要内容函数的声明和调用函数间的参数传递内联函数带默认形参值的函数函数重载C++系统函数31函数定义的语法形式类型标识符函数名（形式参数表）{

语句序列}函数的声明与使用是被初始化的内部变量，寿命和可见性仅限于函数内部若无返回值，则为无参函数，写Void函数的定义voidprintstar(void){……}有参还是无参？32递归调用函数直接或间接地调用自身，称为递归调用。递归过程的两个阶段：递推：

4!=4×3!→3!=3×2!→2!=2×1!→1!=1×0!→0!=1未知已知回归：4!=4×3!=24←3!=3×2!=6←2!=2×1!=2←1!=1×0!=1←0!=1未知已知函数的声明与使用33例3-8求n!分析：计算n!的公式如下：这是一个递归形式的公式，应该用递归函数实现。函数的声明与使用源程序：#include<iostream>usingnamespacestd;longfac(intn){longf;if(n<0)

cout<<"n<0,dataerror!"<<endl;

elseif(n==0)f=1;elsef=fac(n-1)*n;

return(f);}34intmain(){longfac(intn);

intn;longy;

cout<<"Enterapositiveinteger:";

cin>>n;y=fac(n);

cout<<n<<"!="<<y<<endl;}运行结果：Enterapositiveinteger:88!=403203536函数的参数传递机制

——传递参数值在函数被调用时才分配形参的存储单元。实参可以是常量、变量或表达式。实参类型必须与形参相符。传递时是传递参数值，即单向传递。函数的声明与使用37例3-12输入两个整数交换后输出#include<iostream>usingnamespacestd;voidSwap(int&a,int&b);intmain(){ intx(5),y(10);

cout<<"x="<<x<<"y="<<y<<endl;

Swap(x,y);

cout<<"x="<<x<<"y="<<y<<endl; return0;}voidSwap(int&a,int&b){ intt; t=a; a=b; b=t;}函数的声明与使用运行结果:x=5y=10x=10y=538内联函数声明与使用声明时使用关键字inline。编译时在调用处用函数体进行替换,节省了参数传递、控制转移等开销。注意：内联函数体内不能有循环语句和switch语句。内联函数的定义必须出现在内联函数第一次被调用之前。对内联函数不能进行异常接口声明。内联函数39默认形参值的说明次序默认形参值必须从右向左顺序声明，并且在默认形参值的右面不能有非默认形参值的参数。因为调用时实参取代形参是从左向右的顺序。例：int

add(int

x,inty=5,intz=6);//正确int

add(intx=1,inty=5,intz);//错误int

add(intx=1,inty,intz=6);//错误带默认形参值的函数40重载函数的声明C++允许功能相近的函数在相同的作用域内以相同函数名声明，从而形成重载。方便使用，便于记忆。例：形参类型不同int

add(int

x,inty);floatadd(float

x,floaty);形参个数不同int

add(int

x,inty);int

add(int

x,int

y,intz);

函数重载41注意事项不要将不同功能的函数声明为重载函数，以免出现调用结果的误解、混淆。这样不好：int

add(int

x,int

y);int

add(int

a,int

b);编译器不以形参名来区分int

add(int

x,inty);voidadd(int

x,inty);编译器不以返回值来区分int

add(int

x,inty){returnx+y;}floatadd(float

x,floaty){returnx-y;}

函数重载重载函数的形参必须不同:个数不同或类型不同。编译程序将根据实参和形参的类型及个数的最佳匹配来选择调用哪一个函数。例1：以下叙述正确的是＿。A．建立内联函数的主要目的是提高程序的执行效率B．建立内联函数的主要目的是减少程序文件所占用的内存C．内联函数的参数传递关系与一般函数的参数传递关系不同D.任意函数均可定义成为内联函数解：内联函数是使用更多的存储空间，减少执行时间，即采用空间换取时间，以提高程序执行效率，当多次调用同一内联函数时，程序会增大占用空间。除了在函数体内含有循环语句、swich语句的函数和递归函数不能定义为内联函数以外，其余均可定义成内联函数。内联函数参数传递关系与一般的函数相同。A例2：下面程序的输出结果为＿#include<iostream.h>f(inta){intb=0;staticintc=3;b++;c++;return(a+b+c);}voidmain(){inta=2,I;for(I=0;I<3;I++)cout<<f(a)<<endl;}AA.7B.7C.7D.7

8

710

9

9

71311注：静态局部变量c的特点：在编译时候只赋一次初值，以后每次调用函数时不再重新赋初值而是保留上次函数调用结束时的值例3：关于函数的声明和定义正确的是＿A．函数的声明是必须的，只有这样才能保证编译系统对调用表达式和函数之间的参数进行检测，以确保参数的传递正确B．函数的定义和声明可以合二为一，可以只有函数定义即可C．函数在声明时，其参数标识符可省略，但参数的类型、个数与顺序不能省略D．函数的存储类型为外部型，所以可以在其他函数中被调用，它在定义时象其他外部变量一样，可以在其他函数内定义解：函数的声明并非必须，可以只要函数定义而不要声明，但要注意符合一定条件，函数不可嵌套定义。C3-15编写递归函数GetPower(intx，inty)计算x的y次幂，在主程序中实现输入输出。

解：源程序：#include<iostream.h>longGetPower(intx，inty);intmain(){intnumber，power;longanswer;cout<<"Enteranumber:";cin>>number;cout<<"Towhatpower?";cin>>power;answer=GetPower(number，power);cout<<number<<"tothe"<<power<<"thpoweris"<<answer<<endl;return0;}longGetPower(intx，inty){if(y==1)returnx;elsereturn(x*GetPower(x，y-1));}程序运行输出：Enteranumber:3Towhatpower?43tothe4thpoweris81第四章类与对象面向对象程序设计A

本章主要内容４．１面向对象的思想４．２OOP的基本特点４．３类与对象４．４构造函数与析构函数４．５类的组合４．６类模板４．７面向对象标记４．３．１类的声明形式

类是一种用户自定义类型，声明形式：class类名称{public:

公有成员（外部接口）

private:

私有成员

protected:

保护型成员}类的成员classClock{public:

voidSetTime(int

NewH,int

NewM,

int

NewS);

voidShowTime（）;private:

int

Hour,Minute,Second;};成员数据成员函数４．３．４对象类的对象是该类的某一特定实体，即类类型的变量。声明形式：

类名对象名；例：

ClockmyClock;类中成员的访问方式类中成员互访直接使用成员名类外访问使用“对象名.成员名”方式访问

public

属性的成员构造函数的作用是在对象被创建时使用特定的值构造对象，或者说将对象初始化为一个特定的状态。在对象创建时由系统自动调用。如果程序中未声明，则系统自动产生出一个缺省形式的构造函数允许为内联函数、重载函数、带缺省形参值的函数4.4构造函数与析构函数构造函数--由于类的封装性,不能象普通变量一样初始化

structSavings

{unsignedaccountNumber;

floatbalance;

};

SavingsA={1,2000.0};

SavingsB(2,3000.0);构造函数举例classClock{public:

Clock(int

NewH,int

NewM,int

NewS);//构造函数

voidSetTime(int

NewH,int

NewM,int

NewS); voidShowTime（）;private:

int

Hour,Minute,Second;};构造函数的实现：Clock::Clock(int

NewH,int

NewM,int

NewS){ Hour=NewH; Minute=NewM; Second=NewS;}建立对象时构造函数的作用：voidmain（）{

Clockc(0,0,0);//隐含调用构造函数，将初始值作为实参。

c.ShowTime（）;}4.4.2拷贝构造函数拷贝构造函数是一种特殊的构造函数，其形参为本类的对象引用。

作用：使用一个对象（参数指定的对象），去初始化一个正在被建立的同类型对象class类名{public:

类名（形参）；//构造函数类名（类名&对象名）；//拷贝构造函数

...}；类名::类名（类名&对象名）//拷贝构造函数的实现{函数体}例4-2拷贝构造函数举例(1)当用类的一个对象去初始化该类的另一个对象时系统自动调用它实现拷贝赋值。voidmain(void){PointA(1,2);PointB(A);//拷贝构造函数被调用

cout<<B.GetX（）<<endl;}拷贝构造函数举例(例4-2)

(2)若函数的形参为类对象，调用函数时，实参赋值给形参，系统自动调用拷贝构造函数。例如：voidfun1(Pointp){cout<<p.GetX（）<<endl;}voidmain（）{PointA(1,2);fun1(A);//调用拷贝构造函数}

拷贝构造函数举例(例4-2)(3)当函数的返回值是类对象时，系统自动调用拷贝构造函数。例如：Pointfun2（）{PointA(1,2);returnA;//调用拷贝构造函数}voidmain（）{PointB;B=fun2（）;}4.4.3析构函数完成对象被删除前的一些清理工作。在对象的生存期结束的时刻系统自动调用它，然后再释放此对象所属的空间。如果程序中未声明析构函数，编译器将自动产生一个缺省的析构函数。组合的概念类中的成员数据是另一个类的对象。可以在已有的抽象的基础上实现更复杂的抽象。４．５类的组合通过对复杂对象进行分解、抽象，使我们能够将一个复杂对象理解为简单对象的组合。分解得到复杂对象的部件对象，这些部件对象比它高层的复杂对象更容易理解和实现。然后由这些部件对象来“装配”复杂对象。类组合的构造函数设计原则：不仅要负责对本类中的基本类型成员数据赋初值，也要对对象成员初始化。声明形式：类名::类名(对象成员所需的形参，本类成员形参)

：对象1(参数)，对象2(参数)，{本类初始化}Point(intxx=0,intyy=0){x=xx;y=yy;}Distance::Distance(Point

a,Point

b,doublep):p1(a),p2(b){doublex=double(p1.GetX()-p2.GetX());doubley=double(p1.GetY()-p2.GetY());dist=sqrt(x*x+y*y);price=p;}４．６类模板template<模板参数表>类声明使用类模板使用户可以为类声明一种模式，使得类中的某些数据成员、某些成员函数的参数、某些成员函数的返回值，能取任意类型（包括系统预定义的和用户自定义的）。定义一个类模板与定义函数模板的格式类似，必须以关键字template开始，后面是尖括号括起来的模板参数，然后是类名，其格式如下：

template<classType>class类名{

／／．．．

}；其中template是一个声明模板的关键字，它表示声明一个模板。关键字class表明后面的Type是模板参数。类模板Store<T>模板类Store<int>模板类Store<Student>模板类Store<double>实例化实例化4-14定义一个tree类，有成员ages，成员函数grow(intyears)对ages加上years,age()显示tree对象的ages的值。解：#include<iostream.h>classTree{intages;public:Tree(intn=0);~Tree();voidgrow(intyears);voidage();};Tree::Tree(intn){ages=n;}Tree::~Tree(){age();}voidTree::grow(intyears){ages+=years;}voidTree::age(){cout<<"这棵树的年龄为"<<ages<<endl;}voidmain(){Treet(12);t.age();t.grow(4);}程序运行输出：这棵树的年龄为12这棵树的年龄为16第五章

数据的共享与保护面向对象程序设计A

本章主要内容作用域与可见性对象的生存期数据与函数静态成员共享数据的保护友元编译预处理命令多文件结构和工程５．２对象的生存期对象从产生到结束的这段时间就是它的生存期。在对象生存期内，对象将保持它的值，直到被更新为止。５．２．１静态生存期这种生存期与程序的运行期相同。在文件作用域中声明的对象具有这种生存期。在函数内部声明静态生存期对象，要冠以关键字static

。例：staticinti;#include<iostream.h>int

i=5;//文件作用域intmain（）{

cout<<"i="<<i<<endl;return0;}i具有静态生存期例#include<iostream.h>//文件作用域intmain（）{staticint

i=5;

cout<<"i="<<i<<endl;return0;}i具有静态生存期５．２．２动态生存期块作用域中声明的对象是动态生存期的对象（习惯称局部生存期对象）。开始于程序执行到声明点时，结束于命名该标识符的作用域结束处。#include<iostream.h>voidfun（）;voidmain（）{fun（）;fun（）;}voidfun（）{static

int

a=1;

int

i=5;

a++;

i++;

cout<<"i="<<i<<",a="<<a<<endl;}运行结果：i=6,a=2i=6,a=3i是动态生存期a是静态生存期例５．４静态成员全局对象不好，但复杂程序都是由许多程序员共同设计的，因此需要这种性质的对象。使用类中的静态数据成员——解决访问权限控制问题。classemployee{private:

int

EmpNo;

intID;char*name;……}如：需统计雇员总数，数据存放在什么地方？

一个类的所有对象具有相同的属性。属性值不同。类属性；描述类的所有对象的共同特征的一个数据项，对于任何对象实例。它的属性值是相同的静态数据成员用关键字static声明该类的所有对象维护该成员的同一个拷贝必须在类外定义和初始化，用(::)来指明所属的类。例5-4具有静态数据成员的Point类#include<iostream.h>classPoint {public:

Point(intxx=0,int

yy=0){X=xx;Y=yy;countP++;}

Point(Point&p);

int

GetX（）{returnX;}

int

GetY（）{returnY;} voidGetC（）{cout<<"Objectid="<<countP<<endl;}private:

intX,Y;

staticint

countP;统计对象的个数};Point::Point(Point&p){ X=p.X; Y=p.Y;

countP++;}int

Point::countP=0;voidmain（） { PointA(4,5);

cout<<"PointA,"<<A.GetX（）<<","<<A.GetY（）;

A.GetC（）; PointB(A);

cout<<"PointB,"<<B.GetX（）<<","<<B.GetY（）;

B.GetC（）; }在类的声明中仅仅对静态数据成员进行引用性说明，必须在文件作用域的某个地方使用类名限定进行定义性说明，这时也可初始化。注意（１）用类名初始化（２）访问控制属性友元是C++提供的一种破坏数据封装和数据隐藏的机制。通过将一个模块声明为另一个模块的友元，一个模块能够引用到另一个模块中本是被隐藏的信息。可以使用友元函数和友元类。为了确保数据的完整性，及数据封装与隐藏的原则，建议尽量不使用或少使用友元。友元5.5.1友元函数友元函数是在类声明中由关键字friend修饰说明的非成员函数，在它的函数体中能够通过对象名访问private和protected成员作用：增加灵活性，使程序员可以在封装和快速性方面做合理选择。访问对象中的成员必须通过对象名。５．５．２友元类若一个类为另一个类的友元，则此类的所有成员都能访问对方类的私有成员。声明语法：将友元类名在另一个类中使用friend修饰说明。例２：classA{public:

voidDisplay（）{cout<<x<<endl;}private:

intx;}classB{public:voidSet(inti);voidDisplay（）;private:

Aa;};friendclassB;voidB::Set(inti){a.x=i;}常类型

常类型的对象必须进行初始化，而且不能被更新。常引用：被引用的对象不能被更新。const类型说明符&引用名常对象：必须进行初始化,不能被更新。类名const对象名常数组：数组元素不能被更新(下一章介绍)。类型说明符const数组名[大小]...常指针：指向常量的指针(下一章介绍)。５．６共享数据的保护#include<iostream.h>voiddisplay(constdouble&r);intmain（）{doubled＝9.5;

display(d);return0;}voiddisplay(constdouble&r)//常引用做形参，在函数中不能更新r所引用的对象。{cout<<r<<endl;}例5-7常引用做形参５．６．１常引用：被引用的对象不能被更新。const类型说明符&引用名classA{public:

A(int

i,intj){x=i;y=j;}...private:

int

x,y;};Aconst

a(3,4);//a是常对象，不能被更新５．６．２常对象必须进行初始化,不能被更新。

类名const对象名５．６．３用const修饰的对象成员１、常成员函数使用const关键字说明的函数。常成员函数不更新对象的数据成员。常成员函数说明格式：

类型说明符函数名（参数表）const;

这里，const是函数类型的一个组成部分，因此在实现部分也要带const关键字。const关键字可以被用于参与对重载函数的区分通过常对象只能调用它的常成员函数，其它成员函数不能调用。２、常数据成员使用const说明的数据成员。多文件问题//main.cpp#include”file1.h”#include”file2.h”voidmain(){….}//file1.h#include”head.h”….//file2.h#include”head.h”….//head.hclasspoint{….}//head.h#ifndefHEAD_H#defineHEAD_Hclasspoint{….}#endif5-3下面的程序的运行结果是什么，实际运行一下，看看与你的设想有何不同。#include<iostream.h>voidmyFunction();intx=5，y=7;intmain(){cout<<"xfrommain:"<<x<<"\n";cout<<"yfrommain:"<<y<<"\n\n";myFunction();cout<<"BackfrommyFunction!\n\n";cout<<"xfrommain:"<<x<<"\n";cout<<"yfrommain:"<<y<<"\n";return0;}voidmyFunction(){inty=10;cout<<"xfrommyFunction:"<<x<<"\n";cout<<"yfrommyFunction:"<<y<<"\n\n";}xfrommain:5yfrommain:7xfrommyFunction:5yfrommyFunction:10BackfrommyFunction!xfrommain:5yfrommain:7第六章

数组与指针面向对象程序设计A

本章主要内容6.1数组6.2指针6.3动态存储分配6.4字符串指针小结指针变量可以指向任何类型的对象，它指向数组、结构、函数，数组的数组元素，结构的成员，函数的参数也都可以是指针类型。理解和构造多种说明符：先撇开标识符，按从右到左的顺序逐个解释每个说明符，如果有括号改变解释的先后，先解释括号内再解释括号外。例：int*p[5];5个元素的数组，每个元素为一指针，指针指向整型。即P为指针数组有5个整型指针的数组。int(*p)[5]；是一个指针，指向含有5个元素的数组，每个元素是整型，P为指向含有5个整型数的数组指针。例：inti,*ip,f();*fp(),(*pf)(),*(*fp)();inta[5],*ap[5],(*pa)[5];i：整型ip：指向整型的指针f：返回值为整型的函数fp：返回整型指针的函数，fp返回的是一个指向整型变量的指针pf：指向函数的指针，此函数返回整型pfp：指向函数的指针，此函数返回整型指针a：含5个整型元素的数组ap：指针数组，每个元素是指向整型的指针pa：指向整型数组的指针，该数组有5个整型的元素6.7动态内存分配动态申请内存操作符newnew类型名T（初值列表）功能：在程序执行期间，申请用于存放T类型对象的内存空间，并依初值列表赋以初值。结果值：成功：T类型的指针，指向新分配的内存。失败：0（NULL）释放内存操作符deletedelete指针P功能：释放指针P所指向的内存。P必须是new操作的返回值。动态分配数组时应注意：用new创建多维数组：new类型名T[下标表达式1][下标表达式2]…；如果内存申请成功，new运算返回一个指向新分配内存首地址的指针，是一个T类型的数组，数组元素的个数为除最左边一维外各位下标表达式的乘积。例如：char(*fp)[3];fp=newchar[2][3];6.8用字符数组存储和处理字符串字符数组的声明和引用例：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-19例6-20整行输入字符串cin.getline(字符数组名St,字符个数N,结束符);功能：一次连续读入多个字符（可以包括空格），直到读满N个，或遇到指定的结束符（缺省为'\n'）。读入的字符串存放于字符数组St中。读取但不存储结束符。cin.get(字符数组名St,字符个数N,结束符);功能：一次连续读入多个字符（可以包括空格），直到读满N个，或遇到指定的结束符（缺省为'\n'）。读入的字符串存放于字符数组St中。

既不读取也不存储结束符。字符串处理函数strcat（连接），strcpy（复制），

strcmp（比较），strlen（求长度），

strlwr(转换为小写），

strupr（转换为大写）头文件<string.h>6-26编写一个矩阵转置的函数，矩阵的行数和列数在程序中由用户输入。

#include<iostream.h>voidmove(int*matrix1,int

m,intn){inti,j,k;Int*matrix2=newint[n*m];for(i=0;i<n;i++)for(j=0;j<m;j++){*(matrix2+i*m+j)=*(matrix1+j*m+i);cout<<*(matrix2+i*m+j)<<““;}cout<<endl;}voidmain(){intm,n,i,j;int*p;cout<<"请输入矩阵的维数：";cin>>m;cin>>n;p=newint[m*n];cout<<"输入矩阵的元素"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++){cout<<"第"<<i+1<<"行第"<<j+1<<"个元素为：";cin>>p[i*m+j];}cout<<"输入的矩阵的为："<<endl;for(i=0;i<m;i++){for(j=0;j<n;j++)cout<<p[i*m+j]<<"";cout<<endl;}cout<<"转置后的矩阵的为："<<endl;move(p,m,n);Delete[]p;}第七章继承与派生面向对象程序设计A

#include<iostream.h>classShape{public:Shape(){} ~Shape(){} virtualfloatGetArea(){return-1;}};classCircle:publicShape{public: Circle(floatradius):itsRadius(radius){} ~Circle(){} floatGetArea(){return3.14*itsRadius*itsRadius;}private: floatitsRadius;};7_5定义一个Shape基类，在此基础上派生出Rectangle和Circle，二者都有GetArea()函数计算对象的面积。使用Rectangle类创建一个派生类Square。classRectangle:publicShape{public: Rectangle(floatlen,float

idth):itsLength(len),itsWidth(width){}; ~Rectangle(){}; floatGetArea(){return

itsLength*itsWidth;} floatGetLength(){return

itsLength;} floatGetWidth(){return

itsWidth;}private: floatitsWidth; floatitsLength;};classSquare:publicRectangle{public: Square(floatlen); ~Square(){}};Square::Square(floatlen):Rectangle(len,len){}voidmain(){ Shape*sp; sp=newCircle(5);

cout<<"theareaoftheCircleis"<<sp->GetArea()<<endl; deletesp; sp=newRectangle(4,6);

cout<<"theareaoftheRectangleis"<<sp->GetArea()<<endl;deletesp; sp=newSquare(5);

cout<<"theareaoftheSquareis"<<sp->GetArea()<<endl; deletesp;}theareaoftheCircleis78.5theareaoftheRectangleis24theareaoftheSquareis25Pressanykeytocontinue第八章多态性面向对象程序设计A

8_6#include<iostream.h>classRectangle{public: Rectangle();

Rectangle(intwidth,intlength); ~Rectangle(){}

int

GetWidth()const{return

itsWidth;}

int

GetLength()const{return

itsLength;}private:

int

itsWidth;

int

itsLength;};Rectangle::Rectangle(){

itsWidth=5;

itsLength=10;}Rectangle::Rectangle(int

width,intlength){

itsWidth=width;

itsLength=length;}voidmain(){ RectangleRect1;

cout<<"Rect1width:“

<<Rect1.GetWidth()<<endl;

cout<<"Rect1length:“

<<Rect1.GetLength()<<endl;

int

aWidth,aLength;

cout<<"Enterawidth:";

cin>>aWidth;

cout<<"\nEnteralength:";

cin>>aLength; RectangleRect2(aWidth,aLength);

cout<<"\nRect2width:"

<<Rect2.GetWidth()<<endl;

cout<<"\nRect2length:"

<<Rect2.GetLength()<<endl;}Rect1width:5Rect1length:10Enterawidth:50Enteralength:60Rect2width:50Rect2length:60Pressanykeytocontinue第九章群体类面向对象程序设计A

9_1#include<iostream.h>#include"9_1.h"voidmain(){

intn; doubleAverScore,TotalScore=0;

cout<<"请输入学生人数";

cin>>n; Array<float>Score(n); for(inti=0;i<n;i++) {

cout<<"请输入第"<<i+1<<"个学生的课程A成绩（0~100):";

cin>>Score[i];

TotalScore+=Score[i]; }

AverScore=TotalScore/n;

cout<<"平均成绩为"<<AverScore<<endl;}第十章

群体数据的组织面向对象程序设计A

3.本程序采用缩小区间的方法实现排序。缩小区间的方法是每次在区间范围内找一最小数与最大数，将最小数与最大数分别置于该区间的最前面和最后面，然后从区间中去掉此最前最后的两元素，再重复上述的过程，直至区间长度<=1为止。#include<iostream.h>voidmain(){____(1)_____;int

a[n],max,min,i,j,imax,imin,k;for(i=0;i<n;i++)cin>>a[i];for(i=0;i<n/2;i++){imax=i; max=a[i]; imin=i; min=max;for(j=i+1;___(2)_____;j++)if(a[j]<min) { min=a[j]; imin=j; }else{ if(a[j]>max) { max=a[j]; imax=j; } }if(__3)____) { a[imin]=a[i];a[i]=min;

if(i==imax)___(4)____;}if(imax!=(n-i-1)) { a[imax]=a[n-i-1]; a[n-i-1]=max;}} for(i=0;i<n;i++)cout<<a[i]<<""; }

(1)constintn=10(2)j<n-i(3)i!=imin

(4)imax=imin

输入想查找的数据12数据为：12345678910111213141516171819200-858993460191091910141312是第12个数据Pressanykeytocontinue}第十一章

流类库与输入/输出面向对象程序设计A

#include<fstream.h>classdog{public:

dog(intweight,longdays) {itsWeight=weight;

itsNumberDaysAlive=days; } ~dog(){}

int

GetWeight()const{return

itsWeight;} voidSetWeight(int

weight){itsWeight=weight;} longGetDaysAlive()const{return

itsNumberDaysAlive;} voidSetDaysAlive(long

days){itsNumberDaysAlive=days;}private:

int

itsWeight; longitsNumberDaysAlive;};11_6intmain(){ charfileName[80];

cout<<"Pleaseenterthefilename:";