1．面向对象程序设计中的数据隐藏指的是参考答案为: D
A．输入数据必须输入保密口令B．数据经过加密处理 C. 对象内部数据结构上建有防火墙
D．对象内部数据结构的不可访问性
[解析]输入数据必须输入保密口令和数据经过加密处理都不是面向对象程序设计的特征；对象内部数
据结构上也不可能建有防火墙，所以它们都不是面向对象程序设计中所指的数据隐藏。面向对象程序
设计系统中的封装单位是对象，对象之间只能通过接口进行信息交流，外部不能对对象中的数据随意
地进行访问，这就造成了对象内部数据结构的不可访问性，也使得数据被隐藏在对象中。这就是面向
对象程序设计中的数据隐藏所指。
2．下列各项中符合函数重载必须满足的条件的是参考答案为:D
A．必须有不同的参数个数B．对应的参数类型必须不相同 C. A和B必须同时满足D．A和B只要满足一个即可
[解析]我们知道，在同一个作用域中，要实现函数重载必须满足的条件的是：① 有不同的参数个数；或者② 对应的参数有不相同的数据类型，即①和②中只要有一个满足就可以了。当然两者都满足更好，但这不是必须的。
3．下列带缺省值参数的函数说明中，正确的说明是参考答案为:A
A．int Fun(int x,int y=2,int z=3); B．int Fun(int x=1,int y,int z=3);
C. int Fun(int x,int y=2,int z); D．int Fun(int x=1,int y,int z=3);
[解析]在带缺省值参数的函数说明中，正确的说明应该是无缺省值的参数依次排列在参数表的左边，
排完无缺省值的参数后，再依次排列带缺省值的参数。从所给出的四个选项来看，只有“int Fun(int x,int y=2,int z=3)”符合这条规定，其它的都不符合。
4．有如下的对类“CSample”的说明，其中（）是错误的。
class CSample { 参考答案为:A
A．int a=23;
B．CSample();
public:
C．CSample(int val);
D．~ CSample();
}
[解析]在上面对类“CSample”说明中，“CSample()”和“CSample(int val)”是该类重载的构造函数、“~ CSample()”是该类的析构函数，这三个语句都是正确的。错误的语句是“int a=23”，因为它违反了在类的声明（不管是引用性声明，还是定义性声明）中都不能以赋值表达式的形式给它的数据成员进行初始化。
5．已知类A中的一个成员函数的说明如下：
void Set(A &a);
则该函数的参数“A &a”的含义是参考答案为:C
A．指向A的指针为a
B．将变量a的地址赋给类A
C．类A对象引用a用作函数的形参
D．变量A与a按位与后作函数参数
[解析]因为A是一个类，所以“A &a”表示a是类A的对象，但因为对象a的前缀了符号“&”，则“&a”表示是类A的对象引用。所以“A &a”的含义是类A对象引用a用作函数的形参。
6．若类A和类B的定义如下：
class A {
public:
int i,j；
void get()；
}；
class B:A {
int i,j；
protected:
int k；
public:
void make()；
}；
void B::make() { k=i*j； }
则其中（）是非法的表达式。参考答案为:D
A．void get()；
B．int k；
C．void make()；
D．k=i*j；
[解析]对于给定的四项中，前三项都是正确的，只有第四项是错误的。因为，类B是类A的私有派生类（缺省访问类型），所以A中的公类型的数据成员在类B中成为了私有数据成员，但函数“void B::make()”既然是类B的成员函数，则既可访问类A中的公有数据成员，也能访问类B中的私有数据成员，则表达式“k=i*j;”造成了访问的二义性，即其中的i和j，到底是取自类A呢？还是取自类B 呢？
7．下面的主程序中，语句（）是错误的。
class A {
int i;
public:
virtual void fun()=0;
A(int a) { i=a; }
};
class B {
int j;
public:
void fun() { cout<<”B::fun()\n”; }
B(int b,int c) :A(b) { j=c; }
};
void main() 参考答案为:A
A．{ A a(5);
B．A *pa;
C．B b(7);
D．B *pb;
}
[解析]在类A中，函数“virtual void fun()=0”为纯虚函数，因此，类A为抽象类。作为抽象类，它是不能被用来定义具体对象的，而语句“A a(5);”恰恰是定义抽象类的对象的，所以它是错误的
8．拷贝（复制）构造函数的作用是参考答案为:C
A．进行数据类型的转换
B．用对象调用成员函数
C．用对象初始化对象
D．用一般类型的数据初始化对象
[解析]进行数据类型的转换和用一般类型的数据初始化对象都是一般构造函数的功能。用对象调用成员函数不用构造函数，只要用“对象名．成员函数名”即可。所以拷贝（复制）构造函数的作用，只能是用对象来初始化对象。
9．下列说法中，正确的说法是参考答案为:B
A．所有的运算符都能被重载
B．运算符被重载时，它们的优先级与结合性不会改变
C．当需要时，我们可以自定义一个运算符来进行重载
D．每个运算符都可以被重载成成员函数和友元函数
[解析]当重载运算符时，不是所有的运算符都能被重载，有几个运算符是不能被重载的，如三元运算符“？：”、‘．’、‘*’、‘：：’、‘#’等；也不是每个运算符都可以被重载成成员函数和友元函数，如运算符‘=’、‘（）’、‘[]’、和‘→’都只能被重载成成员函数；无论何时，都不能自定义运算符来进行重载，也即重载只能对已有运算符进行；但是运算符被重载时，它们的优先级与结合性不会改变。
10．下面对结构或类中成员的访问中，不正确的访问是参考答案为:A
A．*; （其中pointer为指向类对象的指针）
B．pointer->salary;
C．x=; （其中worker为具有类类型的对象）
D．Location &rA=A1;int x=rA．GetX(); （Location为已定义的类，A1为对象）
[解析]因pointer为指向类对象的指针，所以“pointer->salary”是正确的访问数据成员的形式；因worker为具有类类型的对象，所以“”也是正确的访问数据成员的形式；因Location为已定义的类，A1为对象，所以“Location &rA=A1;int x=rA．GetX();”表示以对象A1初始化对象引用rA，然后由对象引用rA调用成员函数GetX()给变量x赋值，这样的访问成员函数的形式也是正确的；“*;”中，因为运算符‘.’的优先级高于运算符‘*’的优先级，所以相当于“*（）;”，那正确的形式应该是“*（pointer→salary）;”。故“*”是不正确的访问。
11．C++ 对 C 语言作了很多改进，即从面向过程变成为面向对象的主要原因是 ( )D
A.增加了一些新的运算符
B. 允许函数重载，并允许设置缺省参数
C. 规定函数说明符必须用
原型 D. 引进了类和对象的概念
12．下列符号不能组成标识符的是 (A ) A. 连接符 B. 下划线 C. 大小写字母 D. 数字字符
13．类型修饰符 unsigned 不能修饰 (D ) A. char B. int C. long int D. float
14．在 int a=3,int *p=&a ；中， *p 的值是 ( D) A. 变量 a 的地址值 B. 无意义 C. 变量 p 的地址值
15．下列关于指针的操作中，错误的是 (D ) A. 两个同类型的指针可以进行比较运算 B. 可以用一个空指针赋给某个指针 C. 一个指针可以加上两个整数之差 D. 两个同类型的指针可以相加
二，填空题不写解答过程，将正确的答案写在每小题的空格内。错填或不填均无分。
1．面向对象程序设计中的多态性包括静态多态性和动态多态性，前者由____________机制支持，而后者则由____________机制支持。
答：函数重载、虚函数
[解析]静态多态性又称编译时多态性，调用何函数应该在编译之前就知道了，所以必须由函数重载机制来支持。动态多态性又称运行时多态性，调用何函数只有在运行时才知道，所以由虚函数（与指针或引用）机制来支持。
2．由char const *str=”stucture”；所以定义的指针称为____________，关键字const 所修饰的是____________。
答：指向常量的指针、指针所指的字符串
[解析]根据由‘*’在修饰符“const”中位置的不同，它所修饰的对象也不同，“const ”表示所修饰的是指针所指的常量，该指针称为指向常量的指针；“* const”表示所修饰的是指针本身，该指针称为常指针；“* const *”则表示所修饰的是指针本身和指针所指常量，该指针称为指向常量的常指针。
3．引入虚基类的目的是为了解决多重继承中的____________和____________问题。
答：二义性、多占用空间
[解析]在允许多重继承时可能出现两个问题，第一个是公有派生类中的成员通过不同基类调用它们上一级公共基类的同一成员，这就产生了调用的二义性；每一个基类都为它们的上一级公共基类存有备份，这就引起了公共基类的重复存储，也就多占了存储空间。引入虚基类的目的是为了解决多重继承中的这两个问题。
4．构造函数与析构函数所调用的虚函数是____________的函数，因此调用时实现的是____________联编。
答：所在类、静态
[解析]在生成派生类的对象时，先调用基类的构造函数生成基类对象，再调用派生类的构造函数来生成派生类对象。所以当在构造函数中调用虚函数时，当调用基类的构造函数时，此时派生类还未生成，所以它只能调用自己的虚函数；调用派生类构造函数时，它也只能调用自己的虚函数，因为虚函数的调用是不能由派生类调用基类的。在析构派生类对象是时，先调用派生类的析构函数析构掉派生类对象，再调用基类的析构函数来析够掉基类的对象。所以当在析够构函数中调用虚函数时，派生类的析构函数调用的是它自己的虚函数（原因同构造函数），基类的析构函数调用的也是它自己的虚函数，因为此时派生类对象以已被析构掉了。由上可见，当构造函数与析够函数调用虚函数时，它们调用的都是自己类的函数，因此调用时实现的是静态联编。
7．说明一个const成员函数（又称常量成员函数）的方法是，将const写在__________之间，而且它修饰的是__________。
答：函数头与函数体、this指针
[解析]为了说明一个常量成员函数的方法是，将const写在函数头的右圆括号‘）’与函数体的左花括号‘{’之间，而且它修饰的是对象所属的this指针。表示该函数不能修改它所在对象中的数据成员的值。
20．对某个运算符的重载，实际上是用关键字____________与该运算符组成一个运算符函数，而且该运算符函数的返回类型不能是____________的。
答：operater、void
[解析]对某个运算符的重载，实际上是用关键字operater 与该运算符组成一个运算符函数，而且该运算符函数的返回类型不能是无类型的，即不能是void的。
三改错题
1．分析下列程序中的错误，并说明出错原因。
# include
class base {
const int n;
public:
base() { cout<<”Initializing default\n”; }
base(int m) { cout<<”Initializing\n”; n=m; }
~base() { cout<<”Destroying\n”; }
};
void main()
{ base x(1);
base y=x;
}
答：（1） n=m; const数据成员不以该形式赋值
（2）错误处base y=x;，以对象初始化对象
[解析]（1）作为const数据成员n不能用赋值表达式的形式为其赋初值，必须在定义构造函数时在函数头中以“base(int m)：n(m)”形式来初始化。
（2）base y=x; 语句中‘=’不是赋值的意思，而是初始化的意思。即在定义类base的对象y时，以对象x给它初始化，相当于base y（x）;。但是以对象初始化对象时，必须调用拷贝构造函数才行。因程序中没给出拷贝构造函数，也不能调用系统的缺省拷贝构造函数，因用户给出了构造函数后，再也不能调用系统提供的任何缺省构造函数。所以，base y=x；是错误的。
2．分析下列程序中的错误，并说明出错原因。
#include
class A {
int x;
public:
A(int a) { x=a; fun(); }
virtual void fun()=0;
};
class B:public A {
public:
B(int b) :A(b) {}
void fun() { }
};
void main()
{ A aa(5);
B bb(8);
}
答：1）A aa(5); 抽象类不能定义对象
[解析]（1）在构造函数“A(int a)”调用了纯虚函数“fun()”，因构造函数调用虚函数是静态联编，即调用的是它自己类的虚函数。在此调用的是纯虚函数，它只被说明，而未定义，所以不可能被执行，因此出错。
（2）抽象类相当于是对类的引用性声明，所以它只能定义该类的指针和引用，而不能定义它的对象。在此，A为抽象类，而“A aa(5)”却定义了A的对象，因此是错误的。
3．分析下列程序中的错误，并说明出错原因。
#include
class AA {
int aa;
AA(int xx) { aa=xx; }
public:
int get() { return aa; }
~AA() { cout<<”Destroying”< }; main() { AA elem(5); cout<<()< } 答：（1）AA(int xx) 的访问属性错、应具有公有属性 [解析]（1）构造函数虽是由系统自动调用来生成对象的，但一般都是在类外调用，所以它的访问属性必须是公有的。程序中构造函数的访问属性是私有的（缺省值），运行中必定出错。 四.完成程序题（本大题共5小题，每小题4分，共20分） 根据题目要求，完成程序填空。 1．仔细阅读下列求两个点之间距离的程序，根据程序的输出结果在划线处填入正确语句。 class point { float x,y; public: point(float a,float b) { x=a; y=b; } float distance(point &p) { float dx=_____①______; float dy=_____②______; return (float)sqrt(dx*dx+dy*dy); } }; void main() { point p1(2,3),p2(32,43); cout<<③___< } 答：① ② ③distance(p2) [解析]由于求两点之间距离的函数“distance”为成员函数，所以由该函数的this指针所指对象可用作起点（参数之一），另一个用作终点的参数，必须在函数的参数表中显式地给出。dx 和dy分别计算两个结点间x和y坐标间的距离，因此应该为：dx= – x 和 dy = – y。对它们求平方相加后开方即可，得到两点间的距离：(float)srrt(da*da+dy*dy)。在主程序中求p1和p2两个结点之间的距离，由于由p1调用距离函数，所以由p2作为它的参数，即distance(p2)。 2．两个复数只有当它们的实部和虚部分别相等时，才被认为它们相等。在空格处填入合适的内容，以完成下面的程序，使其重载运算符“==”，用以比较两个复数的相等。请在主函数中输出比较的结果。 #include class complex { double real,imag; public: complex(double r,double i) { real=r; imag=i; } bool operator==(complex &); }; int complex:: operator==(complex &com) { return(_____①_____) } void main() { complex c1,,c2,; if(______②______) return cout<<”true\n”; else return cout<<”false\n”; } 答：① (real==&&(imag== ② c1==c2或==(c2) [解析]若两个复数的相等，则必有它们的实数部分和虚数部分都相等，所以运算符重载函数中返回“(real==&&(imag==”，只有real==与imag==都为真时，该函数的返回值才为真。在主程序中，为了比较两个复数c1和c2，可以隐式地写成“c1==c2”，也可显式写成“==(c2)”。 3．下列程序中声明了两个类AA和BB，其中函数“print”是类AA的成员函数，但是类BB的友元函数。请在①、②和③处各填入正确的内容，使程序能正常运行。 #include _____①______; class AA { int t; public: AA(int x) { t=x; } void print(BB &b); }; class BB { int s; public: BB(int y) { s=y; } friend void ___②___print(BB &); }; void ____③_____ { cout<<”AA：”< void main() { AA m(6); BB n(8); (n); } 答：① class BB; ② AA:: ③ AA::print(BB &w) [解析]由于AA类的成员函数“print”是类BB的友元函数，因此它必须有一个BB类的引用作为参 数，以便有引用BB类数据成员的接口。但此时BB类还未定义，为解决此矛盾，在①处先对BB类作引 用性声明“class BB;”，告诉系统BB类在后面定义。因为函数“print”是类AA的成员函数，在类外 定义必须加上类名和作用域分辨符，即在②处加上“AA::”。在BB类外定义“print”时，因是友元， 所以没有加上“BB：：”的必要，但“AA：：”还是必须加的，所以在③处填“AA::print(BB &w)”。 五.程序分析题 1．请分析以下的程序，给出该程序的正确执行结果。 #include using namespace std; int add(int x,int y) Array { return x+y; } void main() { int m=2,n=3; cout<<"1："< m=2,n=3; cout<<"2："< m=2,n=3; cout<<"3："< m=2,n=3; cout<<"4："< } 答：1：7 2：8 3：8 4：9 [解析]在说明答案之前，要说明两个问题： 1）C++语言中，函数参数是压在栈里的，因压栈是从前往后进行的，所以出栈就是从后向前进行的，也 即先取最后的参数，然后再向前逐个取用； 2）对于单加运算，m++是先执行后加1，++m是加1后再执行。 由此，因m=2,n=3;，所以： 1：（m++）+（m+n）=2+（2+3）=7 （m++后执行，且后加1，所以m=2一直未变） 2：（++m）+（m+n）=3+（2+3）=8 （++m后执行，但先加1，执行++m时，m=3了） 3：（m+n）+（m++）=（3+3）+2=8 （先执行m++，后加1，执行m+n时，m=3了） 4：（m+n）+（++m）=（3+3）+3=9; （先执行++m，且先加1，故一开始就有m=3） 3．请分析下面的程序并给出该程序的执行结果。 #include class AA { int a; public: AA() { cout<<”Initualizing AA!\n”; } ~AA() { cout<<”Destroying AA!\n”; }; class BB { int b; AA p; public: BB() { cout<<”Initualizing BB!\n”; } ~BB() { cout<<”Destroying BB!\n”; }; void main() { BB X; cout<<”Ending main!\n”; } 答：Initualizing AA! Initualizing BB! Ending main! Destroying BB! Destroying AA! [解析]虽然在主程序中只定义了一个类BB的对象，但在类BB中声明了类AA的对象作为它的数据成员。当一个类中含有对象作为数据成员时，在生成对象时，先调用成员对象的构造函数，再调用类自己的构造函数，所以输出了“Initualizing AA!”（成员对象构造函数的输出）和“Initualizing BB!”（类自己构造函数的输出）。对象生成后，执行下一句输出语句，则输出“Ending main!”。此时程序结束，调用析构函数来析构掉对象，先调用类自身的析构函数，其输出为“Destroying BB!”，再调用成员对象的析构函数，其输出为“Destroying AA!”。 4．写出下列程序的运行结果。 #include class AA { public: static int n; AA() { n++; } }; int AA::n=0; main() { cout<<”AA::n=”< AA d1; cout<<<< AA d2; cout<<<< AA d3,d4; cout<<<< cout<<<< } 答：AA::n=0 =1 =2 =4 =4 [解析]由于数据成员n的访问属性是公有的，所以在类外可访问它；又它是静态变量，所以具有全局性。在构造函数中，执行的是n++操作，即每次调用构造函数n就加1。当程序开始时，因未定义对象，所以n的值为初始化时的值，则输出为“AA::n=0”。当定义了对象d1后，由于调用了构造函数，则该对象中n=1，故输出“=1”。同理，对象d2输出“=2”。由于接下来生成了两个对象d3和d4，调用两次构造函数，n两次加1，此时n=4，所以下面两条语句的输出为“=4”和“=4”。 5．写出下列程序的输出结果。 #include class AA { public: AA{} { cout<<”Constructor of AA． \n”; fun(); } virtual void fun() { cout<<”AA::fun() called．\n”; } }; class BB:public AA { public: BB(){ cout<<”Constructor of BB．\n”; fun(); } void fun() { cout<<”BB::fun() calle d．\n”; } }; void main() { BB d; } 答：Constructor of AA． AA::fun() called. Constructor of BB. BB::fun() called. [解析]虽然函数fun()说明为虚函数，但当在构造函数中被调用时，呈现的是静态联编，即基类和派生类都调用各自的函数fun()。所以，当生成对象d时，先调用基类的构造函数，在构造函数中又调用自己的函数“fun()”，所以输出为“Constructor of AA．”和“AA::fun() called.”。同理调用派生类的构造函数时，生成的输出为“Constructor of BB.”和“BB::fun() called.”。 6．请给出下面的程序的输出结果。 #include template class T void sort(T* a,int n) { T num; for(int i=0;i { for(int j=i;j if(a[j]>a[j+1]) { num=a[j]; a[j]=a[j+1]; a[j+1]=num; } } for(i=0;i cout< } void main() { int iver[5]={ 12,45,9,23,37 }; double dver[5]= { ,,,, }; sort(iver,5); sort(dver,.5); } 答：9 12 23 37 45 [解析]这是使用模板的例子。函数sort是一个递增的排序函数，T是个模板。当数组是整型数据类型时，它为整型数组排序；当数组为双精度数据类型时，它为双精度数组排序。所以输出如上结果。7．分析以下程序的执行结果 #include<> void main() { int a; int &b=a; fp)(); fp=&Sample::gety; int t=(s.*fp)(); cout<<"v="< } 解：本题说明了类成员函数指针的使用方法。在main()中定义的fp是一个指向Sample类成员函数的指针。执行fp=Sample::getx后。fp指向成员函数getx(),int v=(s.*fp)()语句等价于int (),v=x=2;执行fp=Sample::gety之后，fp指向成员函数gety(),int t=(s.*fp)()语句等价于int t=(),t=x=7。所以输出为： v=2,t=7 11．分析以下程序的执行结果 #include<> class Sample { int x; int y; public: Sample(int a,int b) { x=a;y=b; } int getx(){return x;} int gety(){return y;} }; void main() { int (Sample::*fp)(); fp=&Sample::getx; Sample s(2,7),*p=&s; int v=(p->*fp)(); fp=&Sample::gety; int t=(p->*fp)(); cout<<"v="< } 解：本题说明了类成员函数指针的使用方法。这里通过指向对象的指针来调用指向类成员函数的指针，其原理与上题相似。输出仍为： v=2,t=7 12．分析以下程序的执行结果 #include<> class base { public: base(){cout<<"constructing base class"< ~base(){cout<<"destructing base class"< }; class subs:public base { public: subs(){cout<<"constructing sub class"< ~subs(){cout<<"destructing sub class"< }; void main() { subs s; } 解：本题说明单继承情况下构造函数和析构函数的调用顺序。这里base为基类，subs为派生类。 所以输出为： constructing base class constructing sub class destructing sub class destrcuting base class 注意：在单继承情况下，首先调用基类的构造函数，随后调用派生类的构造函数，析构函数的调用顺序则正好相反。 13．分析以下程序的执行结果： #include<> class base { int n; public: base(int a) { cout<<"constructing base class"< n=a; cout<<"n="< } ~base(){cout<<"destructing base class"< }; class subs:public base { base bobj; int m; public: subs(int a,int b,int c):base(a),bobj(c) { cout<<"constructing sub cass"< m=b; cout<<"m="< } ~subs(){cout<<"destructing sub class"< }; void main() { subs s(1,2,3); } 解：本题说明派生类中含有对象成员情况下构造函数和析构函数的调用顺序。这里base为基类,subs 为派生类，subs类的构造函数中含有对象成员。 所以输出为： constrcuting base class n=1 constructing base class n=3 constructing sub class m=2 destructing sub class destructing base class destructing base class 注意：当派生类中含有对象成员时，构造函数的调用顺序如下： 基类的构造函数 2)对象成员的构造函数 3)派生类的构造函数 析构函数的调用顺序与之相反 14．分析以下程序的执行结果 #include<> class A { public: int n; }; class B:public A{}; class C:public A{}; class D:public B,public C int getn(){return B::n;} }; void main() { D d; ::n=10; ::n=20; cout<<::n<<","<<::n< } 解： D类是从类和类派生的而类和类又都是从类派生的，但各有自己的副本。所以对于对象d，::n 与::n是两个不同的数据成员它们互无联系。 所以输出为： 10，20 15．分析以下程序的执行结果 #include<> class A { public: int n; }; class B:virtual public A{}; class C:virtual public A{}; class D:public B,public C { int getn(){return B::n;} }; void main() { D d; ::n=10; ::n=20; cout<<::n<<","<<::n< } 解： D类是从类和类派生的而类和类又都是从类派生，但这是虚继承关系即是虚基类因此和共用一个的副本所以对于对象d，::n与::n是一个成员。 所以输出为： 20，20 16．分析以下程序执行结果 #include<> int add(int x,int y) { return x+y; double add(double x,double y) { return x+y; } void main() { int a=4,b=6; double c=,d=; cout< } 解：本题说明函数重载的使用方法，这里有两个add()函数，一个add()函数的参数与返回值为int 型，另一个的参数与返回值为double型，它们是根据参数类型自动区分的。 所以输出为： 10，10 17．分析以下程序的执行结果 #include<> class Sample { int i; double d; public: void setdata(int n){i=n;} void setdata(double x){d=x;} void disp() { cout<<"i="< } }; void main() { Sample s; (10); ; (); } 解：本题说明重载成员函数的使用方法。setdata()成员函数有两个，根据其参数类型加以区分。 所以输出为：i=10, d= 22．分析以下程序的执行结果 #include<> class Sample { int n; public: Sample(){} Sample(int i){n=i;} Sample &operator =(Sample); void disp(){cout<<"n="< }; Sample &Sample::operator=(Sample s) { Sample::n=; return *this; } void main() { Sample s1(10),s2; s2=s1; (); } 解：本题说明重载运算符(=)的使用方法。operator=成员函数实现两个对象的赋值。 所以输出为： n=10 六．程序设计题 1．设计一个三角形类Triangle，包含三角形三条边长的私有数据成员，另有一个重载运算符“+”，以实现求两个三角形对象的面积之和。 解：在Triangle类中设计一个友元函数operator+(Triangle t1,Triangle t2)，它重载运算符"+"，返回t1和t2两个三角形的面积之和。 本题程序如下： #include<> #include<> class Triangle { int x,y,z; double area; public: Triangle(int i,int j,int k) { double s; x=i;y=j;z=k; s=(x+y+z)/; area=sqrt(s*(s-x)*(s-y)*(s-z)); } void disparea() { cout<<"Area="< } friend double operator+(Triangle t1,Triangle t2) { return +; } }; void main() { Triangle t1(3,4,5),t2(4,5,6); double s; cout<<"t1:"; (); cout<<"t2:"; (); s=t1+t2; cout<<"总面积="< } 本程序执行结果如下： t1:Area=6 t2:Area= 总面积= 2．重载运算符“+”友元函数只能返回两个三角形的面积之和，不能计算三个三角形的面积之和，改进一下，使之能计算任意多个三角形的面积之和。 解：重载运算符为什么不能计算3个三角形的面积之和呢？对于式子:s=t1+t2+t3，先计算t1+t2，返回一个double数然后再进行该double数+t3的计算，显然没有这样的重载运算符“+”友元函数，只需要添加这样重载运算符“+”友元函数即可。 本题程序如下： #include<> #include<> class Triangle { int x,y,z; double area; public: Triangle(int i,int j,int k) { double s; x=i;y=j;z=k; s=(x+y+z)/; area=sqrt(s*(s-x)*(s-y)*(s-z)); } void disparea() { cout<<"Area="< } friend double operator+(Triangle t1,Triangle t2) { return +; } friend double operator+(double d,Triangle t) { return d+; } }; void main() { Triangle t1(3,4,5),t2(4,5,6),t3(5,6,7),t4(6,7,8); double s; cout<<"t1:"; (); cout<<"t2:"; (); cout<<"t3:"; (); cout<<"t4:"; (); s=t1+t2+t3+t4; cout<<"总面积="< 本程序的执行结果如下： t1:Area=6 t2:Area= t3:Area= t4:Area= 总面积= 3．设计一个学生类student,包括姓名和三门课程成绩，利用重载运算符”+“将所有学生的成绩相加放在一个对象中，再对该对象求各门课程的平均分。解： #include<> #include<> #include<> class student { char name[10]; int deg1,deg2,deg3; public: student(){} student(char na[],int d1,int d2,int d3) { strcpy(name,na); deg1=d1;deg2=d2;deg3=d3; } friend student operator+(student s1,student s2) { static student st; =+; =+; =+; return st; } void disp() { cout< } friend void avg(student &s,int n) { cout< } }; void main() { student s1("Li",77,82,85),s2("Zheng",75,62,89); student s3("Ma",89,87,95),s4("Xu",55,79,65),s; out<<"输出结果"< (); (); s=s1+s2; avg(s,2); (); (); s=s3+s4; avg(s,2); } 运行结果： 输出结果 li 77 82 85 zheng 75 62 89 平均分 76 72 87 Ma 89 87 95 Xu 55 79 65 平均分 72 83 80 4．计算e的值。e是自然对数的底，它和π一样是数学中最常用的无理数常量。其近似值的计算公式为：e=1+1/1!+1/2!+1/3!+...+1/(n-1)!+r 当n充分大时，这个公式可以计算任意精度e的近似值。为了保证误差r<ε，只需1/(n-1)! ( > r) <ε 程序代码如下： // program #include<> void main() { const double eps=; int n=1; float e=,r=; do // 开始do循环。循环条件由后面的while中的表达式值确定。 { e+=r; n++; r/=n; } while(r>eps); cout<<"The approximate Value of natural logarithm base is: "; cout< } 5．16．设计一个立方体类Box，它能计算并输出立方体的体积和表面积。 解： Box类包含三个私有数据成员a(立方体边长)、volume(体积)和area(表面积)，另有两个构造函数以及seta()(设置立方体边长)、getvolume()(计算体积)、getarea()(计算表面积)和disp()(输出结果)。 本题程序如下： #include<> class Box { float a; float volume; float area; public: Box(){} Box(float r){a=r;} void seta(float r){a=r;} void getvolume(){volume=a*a*a;} void getarea(){area=6*a*a;} void disp() { cout<<"体积："< } }; void main() { Box obj1,obj2; ; (); (); cout<<"obj1=>"; (); (); (); cout<<"obj2=>"; (); } 本程序的执行结果如下： obj1=>体积：, 表面积： obj2=>体积：,表面积： 第3章面向对象程序设计基础 第3章面向对象程序设计基础 【1】什么是Java程序使用的类？什么是类库？ 答：类是将一类事物的特性描述出来，然后如果用这个类来定义对象，则该对象就拥有了这个类所描述的所有特性。 在Java系统中，系统定义好的类根据实现的功能不同，可以划分成不同的集合，每个集合称为一个包，所有包合称为类库。 【2】如何定义方法？在面向对象程序设计中方法有什么作用？ 答：方法的定义由两部分组成：方法声明和方法体。 方法的声明如下： 返回值类型方法名（参数类型形式参数1，参数类型形式参数2…）{ 程序代码； 返回值； } 在面向对象程序设计中，方法的作用是完成对类和对象属性操作。 【3】简述构造方法的功能和特点。下面的程序片段是某学生为student类编写的构造方法，请指出其中的错误。 void Student(int no,String name) { studentNo=no; studentName=name; return no; } 答：构造方法的功能是：构造方法是一个特殊的方法，主要用于初始化新创建的对象； 特点：构造方法的方法名要求与类名相同，用户不能直接调用，只能通过new运算符调用，而且构造方法是不返回任何数据类型，甚至也不返回void数据类型，即不能在构造方法前加void。 错误之处：（1）构造方法Student()前不能加void，（2）不能用return语句,(3)类名Student 首字母S改成小写s. 【4】定义一个表示学生的student类，包括的域有学号、姓名、性别、年龄，包括的方法有获得学号、姓名、性别、年龄及修改年龄。编写Java程序创建student类的对象及测试其方法的功能。 class Student { String id; String name; String sex; int age; void talk(){ 《面向对象程序设计》 大作业 题目学生成绩管理系统 学院 专业 班级 姓名 指导教师 2015 年11 月11 日 目录 一大作业的目的 (1) 二大作业的内容............................ . .. (2) 三大作业的要求与数据............... ...... . (3) 四大作业应完成的工作.................. . (4) 五总体设计（包含几大功能模块）........... . (5) 六详细设计（各功能模块的具体实现算法——流程图） (6) 七调试分析（包含各模块的测试用例，及测试结果） (7) 八总结 (8) 十参考资料 (9) 一大作业的目的 《面向对象程序设计》是一门实践性很强的课程，通过大作业不仅可以全方位检验学生知识掌握程度和综合能力，而且还可以进一步加深、巩固所学课程的基本理论知识，理论联系实际，进一步培养自己综合分析问题和解决问题的能力。更好地掌握运用C++语言独立地编写、调试应用程序和进行其它相关设计的技能。 二大作业的内容 对学生信息(包括学号、语文、数学、英语、平均分)进行管理,包括学生成绩的信息输入、输出、查询、删除、排序、统计、退出.将学生的成绩信息进行记录，信息内容包含：（1）学生的学号（2）学生的姓名（3）学生的成绩。假设，现收集到了一个班学生的所有成绩信息，要求用C语言编写一个简单的成绩管理系统，可进行录入、查询、修改和浏览等功能。学习相关开发工具和应用软件，熟悉系统建设过程。 三大作业的要求与数据 1、用C++语言实现系统； 2、对学生信息(包括学号、姓名、语文、数学、英语、平均分)进行管理,包括学生成绩的信息输入、输出、查询、删除、排序、统计、退出. 3、学生信息包括：其内容较多，为了简化讨论，要求设计的管理系统能够完成以下功能： (1) 每一条记录包括一个学生的学号、姓名、3门课成绩 (2)、成绩信息录入功能：(成绩信息用文件保存，可以一次完成若干条记录 的输入。) (3)、成绩信息显示浏览功能：完成全部学生记录的显示。 (4)、查询功能：完成按姓名查找学生记录，并显示。 (5)成绩信息的删除:按学号进行删除某学生的成绩. (6)、排序功能：按学生平均成绩进行排序。 (7)、应提供一个界面来调用各个功能,调用界面和各个功能的操作界面应尽可能清晰美观! 1．对象 （1）从概念层面讲，对象是某种拥有责任的抽象。 （2）从规格层面讲，对象是一系列可以被其他对象使用的公共接口。 （3）从语言实现层面讲，对象封装了代码和数据。 2．软件开发中的经典阶段：需求、分析、设计、规范、实现、测试、部署、维护。 3．设计7原则：开闭原则、里氏代换原则、依赖倒转原则、合成/聚合复用原则、 迪M特原则、接口隔离原则、单一职责原则。 4．面向对象的方法学：UML（统一建模语言）、RUP（统一软件开发过程）、XP（极限 编程）。 开发方法：Booch、Coad、OMT、UML、OOSE、Wirfs—Brock 5．OOA——运用面向对象方法进行需求分析。 OOD——运用面向对象方法进行系统设计。 OOP——运用面向对象方法进行程序设计。 6．OOA的基本任务：是运用面向对象的方法，对问题域和系统责任进行分析和理解，对其中的事物和它们之间的关系产生正确的认识，找出描述问题域及系统责任所需的类及对象，定义这些类和对象的属性和操作，以及它们之间所形成的结构、静态联系和动态联系。最终目的：是产生一个符合用户需求，并能够直接反映问题域和系统责任的OOA模型及其详细说明。 优点：（1）加强了对问题域和系统责任的理解。（2）改进与分析有关的各类人员之间的交流。（3）对需求的变化具有较强的适应性。（4）支持软件复用。 OOA的三大策略是：属性策略、方法策略、对象策略。 7．（1）封装：是指对象在其操作中隐藏属性。它是一种信息隐蔽技术，用户只能看见对象封装界面上的信息，对象的内部实现对用户是隐蔽的。封装的目的是使对象的使用者和生产者分开，使对象的定义和实现分开。 例如：要从同事那里借钱，在商店购买食物，就不会抢夺同事的钱包，大翻一通，看看里 面是否有足够的钱。而应该询问他们是否可以借你一些钱，他们就会自己翻钱包。 以表示圆的一个对象作为封装的例子。圆的操作应能计算出半径、直径、周长和面积。假定选择存储直径，要访问直径的程序员都会选择存储直径属性，而不是通过“获取直径”的操作来访问。如果在软件的后续版本中要存储的是半径，就必须找出系统中直接访问直径的所有代码，并更正它们，有了封装，就不会有问题。 （2）继承：可以指定类从父类中获取一些特性，再添加它自己的独特特性。继承是类间的 基本关系，它是基于层次关系的不同类共享数据和操作的一种机制。父类中定义了其所有子类的公共属性和操作，在子类中除了定义自己特有的属性和操作外，可以继承父类的属性和操作，也可以对父类中的操作重新定义其实现方法。 例如：在面向对象中，我们可以把洗衣机、电冰箱、微波炉、收音机看成是家用电气类的 子类，也可以说家用电器类是这些类的超类。家用电器类具有的属性OnOffSwitch和electricWire，具有turnOn（）和turnOff（）操作。因此，如果你知道某物是家用电器，那么就会立即知道它 具有家用电器类的属性和操作，这种关系就是继承。每个家用电器类的子类都继承了家用电器类的特征。同时，每个子类都增加了自己的属性和操作。 （3）多态：是指同一操作作用于不同的对象上可以有不同的解释，并产生不同的执行结果。例如：“画”操作，作用在“矩形”对象上，则在屏幕上画一个矩形；作用在“圆”对象上， 则在屏幕上画一个圆。也就是说，相同操作的消息发送给不同对象时，每个对象将根据自1 / 9 面向对象程序设计实验指导书 实验一、C++开发环境应用入门（2学时）(选做) 1、实验目的 （1）了解C++开发工具的特点 （2）熟悉C++开发环境 （3）学习用C++编写标准的C++程序 2、实验任务 使用C++来建立一个非图形化的标准C++程序，编译、运行下例程序： #include 实验一熟悉VC++IDE开发环境 一、实验目的 1、熟悉VC++6.0集成开发环境，熟练掌握VC++6.0项目工作区、各种编辑器、菜单栏和工具栏的使用。 2、掌握如何编辑、编译、连接和运行一个C++程序。 3、通过运行简单的C++程序，初步了解C++源程序的结构和特点。 二、实验要求 1、分析下列程序运行的结果。 程序一： #include 2015秋季学期计算机科学与技术本科 《面向对象程序设计技术》作业题 （在电大在线该课程讨论区跟帖提交，注明姓名和学号以记录成绩）选择题 1.可以在本类及派生类的成员函数中进行访问的访问控制修饰符是（B） A.private B.protected C.public 2.在IDE中将编程项目采用多文件结构下，类的定义一般放在（A） A.头文件 B.程序文件 C.主程序文件 3.内联成员函数在类外定义时要将其和类定义一起放在（A） A.头文件 B.程序文件 C.主程序文件 4.下面哪个内存区域是C++中的运行时动态内存分配区域？( D ) A.代码区 B.栈区 C.数据区 D.堆区 5.对象作为函数参数使用时，一般使用（A）形式 A.引用 B.指针 C.对象拷贝 6.同类的多个不同对象的数据成员值各有不同，但不同对象可以共享类的成员函数代码， 实际调用成员函数时，是通过（B ）来区分不同对象的。 A.显式给出不同对象不同地址 B.隐含的this指针 C.引用 7.下面哪一种情况不会自动调用拷贝构造函数。（E） A.用一个对象初始化另一个对象时 B.当一个对象作为值传递给一个函数时 C.当一个对象作为值从一个函数返回之前，该对象被拷贝到栈区 D.函数调用结束后，栈区中的返回对象拷贝给主调程序的对象 E.建立指向对象的指针并初始化指针值时 8.下列哪些对象的数据成员类型可以不用初始化表的方式进行初始化（D） A.常量数据成员 B.引用数据成员 C.类中对象成员 D.一般数据成员 9.下列哪一种类设计一般无需在类中设计静态数据成员以使建立的多个对象共享静态数 据数据成员。( D ) A.一个链表类的头指针和尾指针 B.一个学生类中用于保存建立了多少个学生对象的计数器 C.银行帐号类中的年利率 D.一般只用于建立一个对象的类 10.一个类中的公有（public）性质的静态数据成员，以下哪一种访问方式是错误的（D） A.对象名.静态数据成员名 B.指向对象的指针—>静态数据成员名 C.类名::静态数据成员名 D.类名.静态数据成员名 11.下列哪一个运算符不能够被类所重载（E） A.“.”成员访问运算符 B.“*”成员指针访问运算符 C.“::”域运算符 D.“？:”条件运算符 E.“=”赋值运算符 22. 下列的符号常量定义中，错误的定义是（）。 A. const M=10; B. const int M=20; C. const char ch; D. const bool mark=true; 40. 函数重载是指（）。 A. 两个或两个以上的函数取相同的函数名，但形参的个数或类型不同 B. 两个以上的函数取相同的名字和具有相同的参数个数，但形参的类型可以不同 C. 两个以上的函数名字不同，但形参的个数或类型相同 D. 两个以上的函数取相同的函数名，并且函数的返回类型相同 41. 以下关于函数模板叙述正确的是（）。 A. 函数模板也是一个具体类型的函数 B. 函数模板的类型参数与函数的参数是同一个概念 C. 通过使用不同的类型参数，函数模板可以生成不同类型的函数 D. 用函数模板定义的函数没有类型 42. 下列（）的调用方式是引用调用。 A. 形参和实参都是变量 B.形参是指针，实参是地址值 C. 形参是引用，实参是变量 D.形参是变量，实参是地址值 43. 为了提高程序的运行速度，可将不太复杂的功能用函数实现，此函数应选择（）。 A. 内联函数 B.重载函数 C.递归函数 D.函数模板 44. 函数原型语句正确的是（）。 A. int Function(void a); B.void Function (int); C. int Function(a); D.void int(double a); 45. C++中函数返回值的类型是由（）决定的。 A. return语句中表达式的类型 B.该函数定义时的类型 C.调用函数时的调用语句 D.系统根据结果 56. 采用重载函数的目的是（）。 A. 实现共享 B. 减少空间 C. 提高速度 D. 使用方便，提高可读性 58. 以下叙述中正确的是( )。 A. 使用#define可以为常量定义一个名字，该名字在程序中可以再赋另外的值 B. 使用const定义的常量，其值在程序运行时是不可改变的 C. 在程序中使用内联函数使程序的可读性变差 D. 在定义函数时可以在形参表的任何位置给出缺省形参值 70. 用new运算符创建一个含10个元素的一维整型数组的正确语句是( )。 A. int *p=new a[10]; B. int *p=new float[10]; 《面向对象程序设计》课程实验指导书 实验一 Java开发环境的安装与配置 一、实验目的： 1. 掌握JDK、Eclipse的安装步骤。 2. 理解环境变量PATH, CLASSPATH的作用，以及Eclipse的配置。 3. 熟悉Eclipse的编辑、编译与调试环境，编写简单的Application程序 编译执行并完成调试。 二、实验内容： 熟悉JDK的安装和配置，学习如何编写并运行简单的Application程序 (能输出一条简单的问候信息)； 三、实验要求： 1. 能正确地安装JDK 2. 熟悉环境变量PATH, CLASSPATH设置方法，熟悉编辑环境 3. 调试程序、编译，运行后得到正确的结果 四、实验步骤： 1．从https://www.doczj.com/doc/d018148598.html,/technetwork/java/index.html上下载最新版本的JDK，并安装。 2．设置环境变量PATH, CLASSPATH, 使得Java程序能正确编译和执行。 3．在Eclipse环境下编写一个HelloWorld.java程序， (1)在主方法static public void main(String[ ] args)中调用System. out.println()方法，使程序输出一条问候信息； (2) 编译运行程序，观察运行情况和输出结果。（使用JDK环境，调用 javac.exe和java.exe编译和执行程序） 实验二 Java语言基础 一、实验目的： 熟悉Java基本语法，基本数据类型，各种运算符及表达式的使用，掌握运算符优先级,熟悉使用Java的选择语句,循环语句。 二、实验内容： 1.编写Java Application程序，输出1900年到2000年之间的所有润年。 （闰年的判断条件：能被4整除且不能被100整除，或能被400整除）； 2.金字塔：Pyramid.java 在屏幕上显示一个由星型符号“*”组成的金字塔图案，示例如下： * *** ***** ******* 要求：金字塔高度h,可以由用户设置。 三、实验要求： 1. 正确使用Java语言的选择语句,循环语句； 2. 调试程序、编译，运行后得到正确的结果 3.写出实验报告。要求记录编译和执行Java程序当中的系统错误信息提成 示，并给出解决办法。 四、实验步骤： 1.编写主类； 2.在static public void main(String[ ] args)方法中加入实现要求功能 的代码，主要步骤如下： （第一题）从1900到2000循环，按照闰年的判断条件是则输出1900年到2000年之间的所有润年。 （第二题）允许用户设置金字塔高度。 4. 编译运行程序，观察输出结果是否正确。 1 什么是面向对象程序设计，它与传统的结构式程序有什么不同。 面向对象程序设计是一种适用于设计、开发各类软件的范型。它是将软件看成是一个由对象组成的社会：这些对象具有足够的智能，能理解从其他对象接受的信息，并以适当的行为作出响应；允许低层对象从高层对象继承属性和行为。通过这样的设计思想和方法，将所模拟的现实世界中的事物直接映射到软件系统的解空间。 与传统的结构式程序设计相比，面向对象程序设计吸取了结构式程序设计的一切优点（自顶向下、逐步求精的设计原则）。而二者之间的最大差别表现在： ·面向对象程序采用数据抽象和信息隐藏技术使组成类的数据和操作是不可分割的，避免了结构式程序由于数据和过程分离引起的弊病。 · 面向对象程序是由类定义、对象（类实例）和对象之间的动态联系组成的。而结构式程序是由结构化的数据、过程的定义以及调用过程处理相应的数据组成的 2 用面向对象方法建立模型的思维过程是怎样的。 用面向对象方法建立拟建系统的模型的过程就是从被模拟现实世界的感性具体中抽象要解决的问题概念的过程。这种抽象过程分为知性思维和具体思维两个阶段，其中：·知性思维是从感性材料中分解对象，抽象出一般规定，形成了对对象的普遍认识。·具体思维是从知性思维得到出的一般规定中揭示的事物的深刻本质和规律，其目的是把握具体对象的多样性的统一和不同规定的综合。 3 解释以下概念： ①对象：在现实世界中，对象就是可以感觉到的实体。每个对象具有一个特定的名字以 区别于其他对象；具有一组状态用来描述它的某些特性；具有一组操作，每一个操作决定对象的一种功能或行为（为自身服务的操作和为其他对象提供服务的操作）。而在面向对象系统中，对象是可以标识的存储区域。每个对象的状态被保存在此区域中，而实现一类对象行为的操作（代码）被保存在另外相关的存储器区域中。 ②消息：消息是要求某个对象执行其某种功能操作（方法）的规格说明。因此，消息是 由消息的接收者、消息要求提供的操作（消息名）和必要的参数组成的。 ③类：在现实世界中，类是对一组具有共同特性（属性和行为）的客观对象的抽象。而 在面向对象系统中，类是由程序员自定义的具有特定结构和功能的类型，是一种代码共享的手段。 ④实例：任何一个对象都是该对象所属类的一个具体实例。 ⑤公有消息：是由对象外向对象发送的消息，用于激活该对象的某种方法。 ⑥私有消息：是由对象向自身发送的消息，用于内部操作；该类消息不能从对象外向该 对象发送。 ⑦消息序列：在面向对象系统中一个事件的发生总会有多个对象的多次相互作用才能完 成，使得这些对象能够相互作用的消息组成的序列被称为消息序列。 4 类与实例的关系如何？ 类是创建对象的模板，而对象是实现类的实例。属于同一类的不同实例必须具有： ·相同的操作集合； ·相同的静态属性集合； ·不同的对象名和属性动态值。 学号：姓名： 第三章面向对象程序设计作业 一、判断题 1、一个Java源程序可有多个类，但只仅有一个public类，而且程序名与public类名相同。对 2、如果类A和类B在同一个包中，则除了私有成员外，类A可以访问类B中所有的成员。对 3、接口中的成员变量全部为常量，方法为抽象方法。对 4、抽象类可以有构造方法，可以直接实例化。错 5、对static方法的调用可以不需要类实例。对 6、包含抽象方法的类一定是抽象类。对 7、方法中的形参可以和方法所属类的属性同名。对 8、接口无构造器，不能有实例，也不能定义常量。错 9、类的实例对象的生命周括实例对象的创建、使用、废弃、垃圾的回收。对 10、Java应用程序的入口main方法只有一种定义法。对 二、选择题 1、下列答案正确的是（A ） A) 在同一个Java源文件中可以包含多个类，只能有一个被声明为public B) 在同一个Java源文件中只能包含一个类，并被声明为public C) 在同一个Java源文件中可以包含多个类，都可以被声明为public D) 在同一个Java源文件中可以包含多个类，只能有一个被声明为default 2、Java实现动态多态性是通过（ B ）实现的。 A) 重载B) 覆盖 C) 接口D) 抽象类 3、下列哪一个是正确的方法重载描述（ A ） A) 重载方法的参数类型必须不同 B) 重载方法的参数名称必须不同 C) 返回值类型必须不同 D) 修饰词必须不同 4、final关键字不可以用来修饰（ D ） A) 类B) 成员方法 C) 域D) 接口 5、接口的所有成员方法都具有（ B ）属性 A) private, final B) public, abstract C) static, protected D) static 6、Java的封装性是通过（A ）实现的 A) 访问控制B) 设计内部类 C) 静态域和静态方法D) 包 7、下列接口或类不属于.*包的是（ D ） A) Collection B)Vector C) Map D) Integer 8、下述哪一组方法，是一个类中方法重载的正确写法（ A ） A) int addValue( int a, int b ){return a+b;} C++面向对象程序设计实验报告 学院：信息科学与技术学院 班级：卓越电子1201 姓名：刘强 学号：120910115 实验二 C++面向过程程序设计 实验目的 掌握函数声明、定义和使用的方法 掌握函数递归调用的方法 实验内容 1、编写一个函数，求数列运算中从n个不同的数中取r个数的所有选择的个数，要求如下：主程序中设计一个循环，不断从输入接收n和r的值，计算结果并输出，当用户输入0 0时，程序结束； 能检查输入数据的合法性，要求n>=1并且n>=r； 能得到正确结果。 输入：5 3输出：10 输入：10 20；输出：Input Invalid !； 输入：-1 4；输出：Input Invalid!； 步骤： 利用一个函数fn(int n)计算n!， 利用另一个函数Cnr(int n, int r)计算Cnr，在该函数中调用fn()， 程序代码： #include int Cnr(int n,int r) { cout<<"Please input two numbers:"< 面向对象程序设计教程（C++语言描述）题解与课程设计指导 第1章 面向对象程序设计概论 一、名词解释 抽象封装消息 【问题解答】 面向对象方法中的抽象是指对具体问题（对象）进行概括，抽出一类对象的公共性质并加以描述的过程。 面向对象方法中的封装就是把抽象出来的对象的属性和行为结合成一个独立的单位，并尽可能隐蔽对象的内部细节。 消息是面向对象程序设计用来描述对象之间通信的机制。一个消息就是一个对象要求另一个对象实施某种操作的一个请求。 二、填空题 （1）目前有面向过程的结构化程序设计方法和面向对象的程序设计方法两种重要的程序设计方法。 （2）结构化程序设计方法中的模块由顺序、选择和循环3种基本结构组成。（3）在结构化程序设计方法中，程序可表示为程序=数据结构+算法；而面向对象的程序设计方法，程序可表示为程序=对象+消息。 （4）结构化程序设计方法中的基本模块是过程；而面向对象程序设计方法中的基本模块是类。 （5）面向对象程序设计方法具有抽象性、封装性、继承性和多态性等特点。 三、选择题（至少选一个，可以多选） （1）面向对象程序设计着重于（ B ）的设计。 A. 对象 B. 类 C. 算法 D. 数据 （2）面向对象程序设计中，把对象的属性和行为组织在同一个模块内的机制叫做（C ）。 A. 抽象 B. 继承 C. 封装 D. 多态 （3）在面向对象程序设计中，类通过（ D ）与外界发生关系。 A. 对象 B. 类 C. 消息 D. 接口 （4）面向对象程序设计中，对象与对象之间的通信机制是（C ）。 A. 对象 B. 类 C. 消息 D. 接口 （5）关于C++与C语言的关系的描述中，（D ）是错误的。 A. C语言是C++的一个子集 B. C语言与C++是兼容的 C. C++对C语言进行了一些改进 D. C++和C语言都是面向对象的 【结果分析】 C语言是面向过程的。C++语言是一种经过改进的更为优化的C语言，是一种混合型语言，既面向过程也面向对象。 （6）面向对象的程序设计将数据结构与（ A ）放在一起，作为一个相互依存、不可分割的整体来处理。 资料内容仅供您学习参考，如有不当或者侵权，请联系改正或者删除。 综合实验报告 面向对象程序设计 专业名称: 物联网工程 ___班级: _____ 级2班__ ___________姓名: 你哥哥 学号: 02051928 信息科学与工程学院 二零一三年七月 第一题: (1) 1.1题目概述 (1) 1.2设计思路 (2) 1.3设计说明与调试分析 (2) 1.4编码实现 (2) 1.5程序运行结果 (5) 1.6设计心得 (5) 第二题: (6) 2.1题目概述 (6) 2.2设计思路 (7) 2.3设计说明与调试分析 (7) 2.4编码实现 (7) 2.5程序运行结果 (11) 2.6设计心得 (11) 第一题: 1.1题目概述 用抽象类设计计算二维平面图形图形面积的程序, 在基类TDshape中设计纯虚函数area()和printName(), area()用于计算几何图形的面积, printName()用于打印输出几何图形的类名, 如Triangle类的对象就打印输出”Triangle”。每个具体形状的类则从抽象类TDshape派生, 各自需要定义其它独有的数据成员和成员函数, 而且定义area()和printName()的具体实现代码, 如图所示。 要求编写以TDshape为接口的函数, 借以访问具体类如 Triangle和Rectangle类的成员函数area(), printName ()。1.2设计思路 由简到繁, 逐步实现。 1.3设计说明与调试分析 编写基类TDshape->编写虚函数->编写继承类Triangle ->实例化TDshape和Triangle ->调用基类虚函数实现调用继承类相应函数->同样的方式处理继承类Rectangle. 1.4编码实现 #include 面向对象程序设计教程（C++吾言描述）题解与课程设计指导 面向对象程序设计概论 一、 名词解释 抽象封装消息 【问题解答】 面向对象方法中的抽象是指对具体问题（对象）进行概括，抽出一类对象的公 共性质并加以描述的过程。 面向对象方法中的封装就是把抽象出来的对象的属性和行为结合成一个独立的 单位，并尽可能隐蔽对象的内部细节。 消息是面向对象程序设计用来描述对象之间通信的机制。一个消息就是一个对 象要求另一个对象实施某种操作的一个请求。 二、 填空题 （ 1） 目前有面向过程的结构化程序设计方法和面向对象的程序设计方法两种 重要的程序设计方法。 （2） 结构化程序设计方法中的模块由顺序、选择和循环 3 种基本结构组成。 （ 3） 在结构化程序设计方法中，程序可表示为程序 =数据结构 +算法； 而面向 对象的程序设计方法，程序可表示为程序 =对象 +消息。 （ 4） 结构化程序设计方法中的基本模块是过程； 而面向对象程序设计方法 中的基本模块是类。 （ 5） 面向对象程序设计方法具有抽象性、封装性、继承性和多态性等特点。 三、 选择题（至少选一个，可以多选） （ 1） 面向对象程序设计着重于（ B ）的设计。 A. 对象 B. 类 C. 算法 D. 数据 （ 2） 面向对象程序设计中，把对象的属性和行为组织在同一个模块内的机制 叫做（ C ）。 A. 抽象 B. 继承 C. 封装 D. 多态 （ 3） 在面向对象程序设计中，类通过（ D ）与外界发生关系。 A. 对象 B. 类 C. 消息 D. 接口 （ 4） 面向对象程序设计中，对象与对象之间的通信机制是（ C ）。 A. 对象 B. 类 C. 消息 D. 接口 （5）关于C++与 C 语言的关系的描述中，（D ）是错误的。 A. C 语言是C++勺一个子集 B. C 语言与C++是兼容的 C. C++对C 语言进行了一些改进 D. C++和C 语言都是面向对象的 【结果分析】 C 语言是面向过程的。C++吾言是一种经过改进的更为优化的 C 语言，是一种混 合型语言，既面向过程也面向对象。 （ 6） 面向对象的程序设计将数据结构与（ A ）放在一起，作为一个相互依 存、不可分割的整体来处理。 A. 算法 B. 信息 C. 数据隐藏 D. 数据抽象 第1 面向对象分析/设计课程大作业 银行业务处理系统 13级软件学院测试班 1367004029 曾丹 1.需求分析 随着社会经济的发展，信息化程度的不断深入，银行的传统业务己愈来愈不能满足银行客户的需要。 现今，人们的金融意识、科技意识己经有了很大的提高，在紧张忙碌的生活中，己越来越来不习惯每月奔忙于各银行营业柜台之问去排队缴各种各样的费用了；同时，各种经营单位如电信、移动、供电、煤气、自来水、证券等等一是为了提高服务质量、方便客户，二是为了减轻自己日趋繁重的工作量，纷纷委托银行为其开展代收代付业务：同时，随着我国加入世贸组织的日益临近，我国的银行业将面临更加激烈的同业竞争，如何提供更多的金融产品和更优质的服务，如 何吸引更多的客户，如何利用计算机技术加强银行帐户信息管理、进行银行业务再造，提高银行的工作效率和业务竟争能力是摆在各家银行面前的一个迫切需要解诀的问题。 近几年来，各商业银行加快了与社会各业的合作，利用自身的网点优势和业务特点，为其提供各种高效、快捷的代收代付业务，也就是中间代理业务，目前以与广大人民群众生活密切相关的各项缴费业务如水电费、电话费、手机费等代收业务为主，这些业务开展方式多种多样，但一般都离不开计算机的高效管理支持。 随着代理业务不断发展，业务品种越来越多，各项业务做法互有差异，这就对银行的电子化水平和相应的管理水平提出了更高的要求。如何利用电子化的手段构建一个高效统一的、通用灵活的系统来管理各种各样的业务，是每个商业银行所要研究的课题。支持决策系统的，需要在数据库的基础上，进行联机分析处理，每次处理的数据量大，响应时间长。 特别是银行每天要处理大量的存取款事件，做好存取款是银行工作重要的环节，然而要有效处理必须要有良好的程序和数据管理系统来建立一个良好的软件系统来实现快速、有效、准确、安全的处理银行事物。 主要用于银行的储蓄卡管理系统，它可以帮助我们有效、准确、并且高效实现的完成存取事件。此系统操作方便效率、安全性高，只要客户开户并设定好密码就可以轻松的实现存取款。 系统实现的主要有储蓄卡开户管理、存取款管理、用户查询历史数据显示、注销等功能。 储蓄卡开户管理模块：卡号、姓名、开户金额、身份证号、地址、电话、密码、确认密码和保存组成。（开户金额必须是数字，密码和确认密码必须一样是六位数字） *注销模块：一旦注销该卡号就不存在且余额提醒你取出。 通过该银行账户管理系统地运行，使办公人员可以轻松快捷的完成对账户管理的任务，提高账目管理效率，使银行的账目管理工作系统化、规范化、自动化。 该银行帐目管理信息系统，优点是设计过程思路清晰、模块划分简洁，设计各阶段分工明确。经过实践证明，该划分是合理的，极大得提高了本系统的实现。 Object- Orien ted Programmi ng C++ 主讲成长生 东华大学计算机科学与技术学院 第一章概述 § 1.1 面向对象程序设计的基本思想 C++是基于C语言发展的，又冲破C语言局限的面向对象的程序设计语言。它与Java 语言都作为当前计算机科学的主流语言, 越来越受到用户的欢迎。 要弄清楚什么是面向对象的程序设计, 首先了解和回顾传统的 （ Pascal（或C））结构化程序设计方法及其设计思想、程序结构及特点。SP（Structure Programming）是60 年代诞生的针对当时爆发的所谓”软件危机” , 为此发展形成了现代软件工程学的基础。 SP的总的设计思想是： . 自顶向下、层次化 . 逐步求精、精细化 程序结构是按功能划分基本模块的树型结构, 使模块间的关系尽可能简单独立。因此SP的程序的基本特点是： . 按层次组织模块（战略上划分战役） . 每一模块只有一个入口, 一个出口 ?代码和数据分离（程序=数据结构+算法） 归纳得到： SP 把数据和过程（代码、函数）分离为相互独立的实体, 用数据代表问题空间中的客体借以表示实际问题中的信 息; 程序代码则用来处理加工这些数据。程序员在编程时 必须时刻考虑所要处理的数据结构和类型。对不同的数据格式即使要作同样 的处理计算, 或者要对相同的数据格式作不同的处理都必须编写不同的程序（如两个整型数和两个浮点数相加）。这样的编程方法，即传统的SP方法设计出来的程序或系统其可重用的成分很少。其次把数据和代码作为不同的分离实体时, 总存在着用错误的数据调用正确的程序模块, 或用正确的数据调用错误的程序模块的危险, 从而使数据与程序始终保持兼容, 已成为程序员 的一个沉重的负担。在开发一个大型软件课题中, 当工程进入到 后期若用户改变了方案要求, 很容易使技术人员的前期工作受到摧毁性的打击，使其前功尽弃。为克服以上的弊端或者该SP方法难以控制处理的矛盾而产生了面向对象程序设计方法, 即Object —Oriented Programming ----------- OOP从二十世纪六十年代提出对象 的雏形, 到七十年代美国国防部的专用语言Ada 语言, 直到当前国际上流行的高品味的Java 和C++（Tc++,Balandc++ 及Vc++）, , 应该讲OOP方法与技术吸取了SP的一切优点，同时又正视和顺应现实世界由物质和意识二部分组成。映射到面向对象的解空间就是: 具体事物—对象; 抽象概念—类。 OOP的基本原理是用问题领域的模型来模拟大千世界，从而设计出尽可能直接、自然地表示问题求解方法的软件, 这样的软件由对象组成, 而对象则是完整反映客观世界事物具有不可分割的静态属性（”数据结构” ）与动态行为（”方法” ）的。而且它们是既有联系又 习题一 5、分析下面程序运行的结果。 # 9、输入以下程序，进行编译，观察编译情况，如果有错误，请修改程序，在进行编译，直到没有错误，然后进行连接和运行，分析运行结果。 修改后的程序如下： #include 面向对象程序设计基本概念 面向对象设计是一种把面向对象的思想应用于软件开发过程中，指导开发活动的系统方法，是建立在“对象”概念基础上的方法学。所谓面向对象就是基于对象概念，以对象为中心，以类和继承为构造机制，来认识、理解、刻画客观世界和设计、构建相应的软件系统。 对象：对象是要研究的任何事物。从一本书到一家图书馆，单的整数到整数列庞大的数据库、极其复杂的自动化工厂、航天飞机都可看作对象，它不仅能表示有形的实体，也能表示无形的（抽象的）规则、计划或事件。对象由数据（描述事物的属性）和作用于数据的操作（体现事物的行为）构成一独立整体。从程序设计者来看，对象是一个程序模块，从用户来看，对象为他们提供所希望的行为。 类：类是对象的模板。即类是对一组有相同数据和相同操作的对象的定义，一个类所包含的方法和数据描述一组对象的共同属性和行为。类是在对象之上的抽象，对象则是类的具体化，是类的实例。类可有其子类，也可有其它类，形成类层次结构。 消息：消息是对象之间进行通信的一种规格说明。一般它由三部分组成：接收消息的对象、消息名及实际变元。 面向对象主要特征： 封装性：封装是一种信息隐蔽技术，它体现于类的说明，是对象的重要特性。封装使数据和加工该数据的方法（函数）封装为一个整体，以实现独立性很强的模块，使得用户只能见到对象的外特性（对象能接受哪些消息，具有那些处理能力），而对象的内特性（保存内部状态的私有数据和实现加工能力的算法）对用户是隐蔽的。封装的目的在于把对象的设计者和对象者的使用分开，使用者不必知晓行为实现的细节，只须用设计者提供的消息来访问该对象。 继承性：继承性是子类自动共享父类之间数据和方法的机制。它由类的派生功能体现。一个类直接继承其它类的全部描述，同时可修改和扩充。继承具有传递性。继承分为单继承（一个子类只有一父类）和多重继承（一个类有多个父类）。类的对象是各自封闭的，如果没继承性机制，则类对象中数据、方法就会出现大量重复。继承不仅支持系统的可重用性，而且还促进系统的可扩充性。 多态性：对象根据所接收的消息而做出动作。同一消息为不同的对象接受时可产生完全不同的行动，这种现象称为多态性。利用多态性用户可发送一个通用的信息，而将所有的实现细节都留给接受消息的对象自行决定，如是，同一消息即可调用不同的方法。例如：Print消息被发送给一图或表时调用的打印方法与将同样的Print消息发送给一正文文件而调用的打印方法会完全不同。多态性的实现受到继承性的支持，利用类继承的层次关系，把具有通用功能的协议存放在类层次中尽可能高的地方，而将实现这一功能的不同方法置于较低层次，这样，在这些低层次上生成的对象就能给通用消息以不同的响应。在OOPL中可通过在派生类中重定义基类函数（定义为重载函数或虚函数）来实现多态性。第3章 面向对象程序设计基础
c++面向对象程序设计大作业
面向对象程序设计 复习资料
面向对象程序设计实验指导书讲解
(完整版)《面向对象程序设计》答案
2016年电大面向对象程序设计技术-作业题
面向对象程序设计期末综合练习一(单选题)
《面向对象程序设计》实验指导书
什么是面向对象程序设计
面向对象程序设计(答案)
C++面向对象程序设计实验报告
面向对象程序设计教程答案
面向对象程序设计实验报告完整版
面向对象程序设计教程答案
面向对象程序设计大作业(C++)
面向对象程序设计完整版
面向对象程序设计作业参考答案
面向对象程序设计基本概念
相关主题
文本预览