C++面向对象程序设计模拟试题完成

C++面向对象程序设计模拟试题一

一、单项选择题（本大题共10小题，每小题2分，共20分 1．说明虚函数的关键字是（ ）。A. inline B. virtual C. define D. static 2．在每个C++程序中都必须包含有这样一个函数，该函数的函数名为（ ）。 A. main B. MAIN C. name D. function 3．cout是某个类的标准对象的引用，该类是（ ）。 A. ostream B. istream C. stdout D. stdin 4．如果在类外有函数调用CPoint::func()；则函数func()是类CPoint的（ ）。 A. 私有静态成员函数 B. 公有非静态成员函数 C. 公有静态成员函数 B. 友元函数

5. 如果class类中的所有成员在定义时都没有使用关键字public、private或protected，则所有成员缺省定义为（ ）。A. public B. protected C. private D．static 6．一个类的所有对象共享的是（ ）。A. 私有数据成员 B. 公有数据成员 C. 保护数据成员 D. 静态数据成员 7．动态联编所支持的多态性称为（ ）。A. 虚函数 B. 继承 C. 编译时多态性 D. 运行时多态性 8．定义类模板时要使用关键字（ ）。A. const B. new C. delete D. template 9．对虚基类的定义（ ）。A. 不需要使用虚函数 B. 必须使用虚函数C. 必须使用privatD. 必须使用public 10．类型转换函数（ ）。 A. 不能带有参数 B. 只能带一个参数 C. 只能带2个参数D. 只能带3个参数 二、判断正误题（本大题共6小题，每小题2分，共12分）

1．虚函数在基类和派生类之间定义，且要求函数原型完全一致。 （ ） 2．抽象类可以用来直接创建对象。 （ ） 3．内联函数中可以出现递归语句。 （ ） 4．模板类与类模板的意义完全相同。 （ ） 5．常对象只能调用常成员函数。 （ ） 6．重载函数要求函数有相同的函数名，但具有不同的参数序列。 （ ） 三、填空题（本大题共6小题，每小题2分，共12分）

1．在用C++进行程序设计时，最好用（ ）代替malloc。

2．函数模板中紧随template之后尖括号内的类型参数都要寇以保留字（ ）。 3．编译时多态性可以用（ ）函数实现。

4．拷贝构造函数用它所在类的（ ）作为参数。 5．用关键字static修饰的类的成员称为( )成员。 6．重载运算符“+”的函数名为（ ）。

四、程序分析题（本大题共4小题，每小题5分，共20分）给出下面各程序的输出结果。 1．阅读下面程序，写出输出结果。 #include using namespace std; class CArray {

public: CArray(int iArray[], int iSize):m_pArray(iArray), m_iSize(iSize) { } int GetSize() { return m_iSize; } int &operator[](int iIndex) { return m_pArray[iIndex - 1]; } private: int *m_pArray; // 指向一个数组空间 int m_iSize; // 数组元素个数 };

int main()

{ int s[]={3, 7, 2, 1, 5}; CArray oArray(s, 5); oArray[1] = 9; for (int i = 1; i <= 5; i++) { cout << oArray[i] << \ \ } cout << endl; return 0; }

上面程序的输出结果为：

2．阅读下面程序，写出输出结果。 #include using namespace std; template void Print(Type a[], int n) { for (int i = 0; i < n; i++) { cout << a[i] << \ \ } }

int main()

{ int a[] = { 5, 6, 8}; double b[] = {6.8, 9.6}; Print(a, sizeof(a) / sizeof(int)); Print(b, 2); cout << endl; return 0; }

上面程序的输出结果为：

3．阅读下面程序，写出输出结果。 #include using namespace std; class CTest {public: CTest(int iVar):m_iVar(iVar) { m_iCount++; } ~CTest() { } void Print() const; static int GetCount() { return m_iCount; } private: int m_iVar; static int m_iCount; };

int CTest::m_iCount = 0; void CTest::Print() const

{ cout << this->m_iVar << \ \}

int main()

{ CTest oTest1(6); oTest1.Print(); CTest oTest2(8); oTest2.Print(); cout << CTest::GetCount(); cout << endl; return 0; }

上面程序的输出结果为：

4．阅读下面程序，写出输出结果。 #include using namespace std; class CTest

\ {public: CTest(int iX = 0, int iY = 0, int iZ = 0):m_iZ(iZ) { m_iX = iX; m_iY = iY; } void Print() { cout << m_iX << endl; cout << m_iY << endl; } void Print() const { cout << m_iZ << endl; } private: int m_iX, m_iY; const int m_iZ; };

int main()

{ CTest oTest1; oTest1.Print(); CTest oTest2(1, 6, 8); oTest2.Print(); const CTest oTest3(6, 0, 18); oTest3.Print(); cout << endl; return 0;

}上面程序的输出结果为：

六、编程题（本大题共2个小题，每小题8分，共16分）

1．编写一个函数模板，用于求参数的绝对值，并编写测试程序进行测试。 函数模板声明如下： template Type Abs(Type tVar)

2．定义一个复数类CComplex，定义带有2个参数（其中一个为缺省参数）的构造函数，显示复数值的函数Show()， 重载“+”运算符（用成员函数实现），并编写测试程序进行测试。

C++面向对象程序设计模拟试题二

一、判断题（每题2分，共12×2=24分）

1. 按照标识符的要求，下划线是不能组成正确标识符的。（ ） 2. C++中使用了新的注释符（//），C语言中注释符（/*…*/）不能在C++中使用。（ ） 3. 引用就是某个变量的别名，对引用的操作，实质上就是对被引用的变量的操作。（ ） 4. 在不同类型操作数组成的表达式中，其表达式类型一定是最高类型double型。（ ） 5. For循环是只有可以确定的循环次数时才可使用，否则不能用for循环。（ ） 6. 返回值类型、参数个数和参数类型都相同的函数也可以重载。（ ）

7. 重新定义的标识符在定义它的区域内是可见的，而与其同名的原标识符在此区域内是不可见的但是却是存在的。（ ）

8. 通常的拷贝初始化函数的参数是某个对象的成员名或对象的引用名。（ ） 9. 友元函数是类的成员函数，所以可以存取或修改该类中的私有成员。（ ）

10. 已知：类A中一个成员函数说明如下：void Set(A&a)；其中A &a的含意是将a的地址值赋给变量Set。（ ） 11. 具有转换函数功能的构造函数，是指只能带有一个或两个参数的构造函数。（ ）

12. 多继承情况下，派生类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序，而与派生类构造函数中所定义的成员初始化列表的各项顺序无关。（ ） 二、读程题，写出程序的运行结果。（1~2题每题6分，3~4题每题8分，共28分） 1、#include void main() {

int i(0); while(++i) {

if(i= =10) break; if(i%3!=1) continue; cout<

2、#include int a[8]={1,2,3,4,5,6,7}; void fun(int *pa,int n); void main( ) { int m=8; fun(a,m);

cout<

void fun(int *pa,int n)

{ for (int I=0;I

3、#include void ff(int x),ff(double x); void main()

{ float a(88.18); ff(a);

char b('a'); ff(b); }

void ff(int x)

{ cout<<\ } void ff(double x)

{ cout<<\4、#include class AA { public:

AA(int i,int j) {A=i;B=j;cout<<\ AA(AA &obj) {A=obj.A+1;B=obj.B+2;cout<<\ ~AA() {cout<<\

void print() {cout<<\ private:

int A,B; };

void main() { AA a1(2,3); AA a2(a1); a2.print(); AA *pa=new AA(5,6); pa->print(); delete pa; }

三、编程题（每题10分，共10×2=20分）

1、编写程序求1至100间所有素数之和，其中求素数要求用函数实现；

2、编程打印如下图形： 1 22 333 4444 55555

四、综合分析应用题（共28分）

1、阐述C＋＋中函数三种调用的方式实现机制、特点及其实参、形参的格式，最好用代码说明（10分）。

2、用代码举例说明如何定义指向普通常量的指针、指向一维数组的指针、指向对象的指针、指向类的数据成员的指针和指向类的成员函数的指针。（10分）

3、结合自己学习C＋＋的经历，谈谈你的学习体会（如遇到的问题、错误、解决问题的办法等等），并说说如何提高学习C＋＋的效果？（8分）

C++面向对象程序设计模拟试题三

一、单项选择题（本大题共10小题，每小题2分，共20分） 1．下面有关重载函数的描述中，正确的是（ ）。

A）重载函数必须具有不同的返回值类型 B）重载函数形参个数必须不同 C）重载函数必须具有不同的形参表 D）重载函数名可以不同 2．假定MyCIass为一个类，那么下列的函数说明中，（ ）为该类的析构函数。 A）void~MyClass(); B）~MyClass(int n); C）MyClass( ); D）~MyClass( ); 3．（ ）是以一种完全通用的方法来设计函数或类而不必预先说明将被使用的每个对象的类型。 A）模板 B）类 C）对象 D）函数 4．下面关于静态成员函数的途术中错语的是（ ）。

A. 静态成员函数可以有返回值 B. this指针可以指向静态成员函数 C. 静态成员函数可以具有指针参数 D. 静态成员函数可有具有返回值类型 5．定义类模板时要使用关键字（ ）。A. private B. public C. delete D. template 6．下列是重载乘法运算符的函数原型声明，其中错误的是（ ）。 A）MyClass operator*(double,double);B）MyClass operator*(double,MyClass);

C）MyClass operator*(MyClass,double); D）MyClass operator*(MyClass,MyClass); 7．以下（ ）成员函数表示纯虚函数。 A）virtual int fun(int) B）void fun(int)=0 C）virtual void fun()=0 D）virtual void fun(int){} 8．关于纯虚函数，下列表述中正确的是（ ）。 A）纯虚函数的声明总是以\结束 B）含有纯虚函数的类可以定义对象 C）含有纯虚函数的类是抽象类 D）上面都是错误的 9．（ ）解决二义性问题。A. 只能使用作用域分辨操作符 B. 只能使用虚基类

C. 使用作用域分辨操作符或虚基类 D. 上面都不能

10．实现编译时的多态性要使用（ ）。A）重载函数 B）析构函数 C）构造函数 D）虚函数 二、填空题（本大题共5小题，每小题2分，共10分）

1．定义一个函数名为fun，返回值为int，没有参数的纯虚函数的声明是（ ）。 2．定义静态成员函数应使用关键字（ ）。

3．在C++中，如果类的名称是CTest，则此类的构造函数名称为（ ）。 4．在类的对象被创建时，（ ）函数会被自动调用。 5．类中数据成员和成员函数的默认访问级别为（ ）。 三、完成程序填题（本大题共3个小题，每小题3分，共9分） 1．请完成下面的程序 #include // 预处理命令 using namespace std; // 使用标准命名空间std // 测试静态成员类 class Test {

private: [1] Test int count; // 对象数

public: Test(){ count++; } // 构造函数, 实现对对象进行计数 static void Show(){ cout << \共有\个对象!\ // 显示对象数 };

int Test::count = 0; // 初始化静态数据成员赋初值 int main(void) // 主函数main(void) { Test obj1, obj2, obj3; // 定义对象 Test::Show(); // 显示对象数 return 0; // 返回值0,返回操作系统 }

2．请完成下面的程序 #include // 预处理命令 using namespace std; // 使用标准命名空间std // 整数类 class Integer {private: int a; // 数据成员

public: Integer(int x = 0){ a = x; } // 构造函数 operator int() { return a; } // 类型转换函数 Integer operator+(const Integer &i) const // 重载加法运算符+ { return [c2] ; // 返回和 } };

int main(void) // 主函数main(void) { Integer a(2), b(3), c; // 定义整数对象 c = a + b; // 求和 cout << c << endl; // 显示和 return 0; // 返回值0, 返回操作系统 }3．请完成下面的程序 #include // 预处理命令 using namespace std; // 使用标准命名空间std template class A {private: ElemType a; // 数据成员 public: A(ElemType x): a(x){ } // 构造函数 void Show() const { cout << a << endl; } // 显示a之值 };

int main(void) // 主函数main(void) { A< [3] > obj(\ // 定义对象 obj.Show(); // 显示相关信息 return 0; // 返回值0, 返回操作系统 }

四、程序分析题（本大题共4小题，每小题5分，共20分）给出下面各程序的输出结果。 1．阅读下面程序，写出输出结果。 #include // 预处理命令 using namespace std; // 使用标准命名空间std class Point {private: int x; // x坐标 int y; // y坐标 public: Point(int a = 0, int b = 0):x(a), y(b){} int GetX() const { return x; } int GetY() const { return y; } void SetX(int a) { x = a; } void SetY(int b) { y = b; } };

int main(void) { Point obj1; const Point obj2(9, 98); cout << obj1.GetX() << endl; obj1.SetX(5); cout << obj1.GetX() << endl; obj1.SetY(18); cout << obj1.GetY() << endl; cout << obj2.GetX() << endl; cout << obj2.GetY() << endl; return 0; // 返回值0,返回操作系统 }

上面程序的输出结果为：

2．阅读下面程序，写出输出结果。 #include // 预处理命令 using namespace std; // 使用标准命名空间std class Array {

private: int *elem; // 数组元素存储空间 int size; // 数组元素个数 public: Array(int a[], int sz): elem(a), size(sz){ } // 构造函数 int GetSize(){ return size; } int &operator[](int pos){ return elem[pos - 1]; } // 重载下标运算符[] };

int main(void) { int a[] = {1, 2, 3, 4, 5}; Array obj(a, 5); obj[1] = 8; for (int i = 1; i <= obj.GetSize(); i++) cout << obj[i] << \ \ cout << endl; return 0; }

上面程序的输出结果为：

3．阅读下面程序，写出输出结果。 #include using namespace std; class A {public: A(){ cout << \构造A\ ~A(){ cout << \析构A\};

class B: public A {public: B(){ cout << \构造B\ ~B(){ cout << \析构B\};

int main(void) { B obj; A *p = new A; return 0; }

上面程序的输出结果为：

4．阅读下面程序，写出输出结果。 #include using namespace std; template ElemType f(ElemType x) { return x * (ElemType)5.1; }

template

void f(ElemType x, ElemType y) { x = x * 1.1; y = y * 1.1; cout << x << endl; cout << y << endl;

// 依次输出数组各元素之值 // 返回值0, 返回操作系统 // 预处理命令 // 使用标准命名空间std // 构造函数 // 析构函数 // 构造函数 // 析构函数 // 返回值0, 返回操作系统 // 预处理命令 // 使用标准命名空间std }

int main(void) { cout << f(3.0) << endl; f(1, 2); f(1.0, 2.0); system(\ // 调用库函数system( ), 输出系统提示信息 return 0; // 返回值0, 返回操作系统 }

上面程序的输出结果为：

六、编程题（本大题26分）

编写程序，定义抽象基类Shape(形状)，由它派生出2个派生类：Circle(圆形) 和Rectangle(矩形)，用函数Show()分别显示各种图形的相关信息，最后还要显示所有图形的总面积。

C++面向对象程序设计模拟试题四

一、单项选择题（本大题共10小题，每小题2分，共20分） 1．下列关于C++函数的说明中，正确的是（ ）。

A）内联函数就是定义在另一个函数体内部的函数 B）函数体的最后一条语句必须是return语句 C）调用一个函数之前，如果还没有定义这个函数，必须先声明其原型 D）编译器会根据函数的返回值类型和参数表来区分函数的不同重载形式 2．假定MyCIass为一个类，那么下列的函数说明中，（ ）为该类的无参构造函数。 A）void MyClass(); B）~MyClass(int n); C）MyClass( ); D）~MyClass( ); 3．下列叙述中，错误的是（ ）。 A）派生类可以使用private派生 B）对基类成员的访问必须是无二义性的

C）基类成员的访问能力在派生类中维持不变 D）赋值兼容规则也适用于多继承的组合

4．当一个类的某个函数被说明为virtual时，该函数在该类及其所有派生类中（ ） 。 A. 都是虚函数 B. 只有被重新说明为vittual时才是虚函数 C. 都不是虚函数 D. 上面都不正确 5．派生类的构造函数的成员初始化表中，不能包含（ ）。

A）基类的构造函数B）派生类中子对象的初始化C）基类中子对象的初始化D）派生类中一般数据成员的初始化 6．下列是重载加法运算符的函数原型声明，其中错误的是（ ）。 A）MyClass operator+(double,double); B）MyClass operator+(double,MyClass); C）MyClass operator+(MyClass,double); D）MyClass operator+(MyClass,MyClass);

7．派生类中的成员不能直接访问基类中的（ ）成员。A）public B）private C）virtual D）protected 8．实现运行时的多态性要使用（ ）。A）重载函数 B）析构函数 C）构造函数 D）虚函数 9．如果在类MyClass的外面使用函数调用MyClass::f()；则函数f()是类MyClass的（ ）。 A. 静态成员函数 B. 非静态成员函数 C. 友元函数 D. 前面都不正确 10．由于常对象不能被更新，因此（ ）。 A）通过常对象只能调用它的常成员函数 B）通过常对象只能调用静态成员函数 C）常对象的成员都是常成员 D）通过常对象可以调用任何不改变对象值的成员函数 二、填空题（本大题共5小题，每小题2分，共10分

1．对于派生类的构造函数，在定义对象时构造函数的执行顺序为：先执行调用___________的构造函数，再执行调用子对象类的构造函数，最后执行派生类的构造函数体中的内容。 2．声明类模板应使用关键字（ ）。

3．重载的关系运算符和逻辑运算符的返回类型应当是（ ）。 4．在面向对象方法中，类的实例称为（ ）。 5．在类的对象被释放时，（ ）函数会被自动调用。 三、完成程序填题（本大题共3个小题，每小题3分，共9分） 1．请完成下面的程序 #include // 预处理命令 using namespace std; // 使用标准命名空间std // 测试静态成员类 class Test {private: int a; // 数据成员 public: Test(int x = 0): [1] {} // 构造函数 void Show(){ cout << \ // 显示数据成员之值 };

int main(void) // 主函数main(void) { Test obj(168); // 定义对象 obj.Show(); // 显示数据成员之值 return 0; // 返回值0,返回操作系统 }

2．请完成下面的程序 #include // 预处理命令 using namespace std; // 使用标准命名空间std // 整数类 class Integer {private: int a; // 数据成员 public:

c.Dis( ); return 0;

} 上面程序的输出结果为：

4．若有以下程序: #include class Base {public: void Fun() { cout << \ };

class Derived:public Base { public: void Fun() { cout << \};

int main()

{ Derived a; Base *p; p=&a; p->Fun(); a.Fun(); return 0;

}上面程序的输出结果为：

5．若有以下程序: #include

template void Fun(T1 &x, T2 &y)

{ if (sizeof(T1) > sizeof(T2) ) x = (T1)y; else y = (T2)x; }

int main() { double d; int i ; d = 99.99; i = 88; Fun(d,i); cout << \ return 0;

} 上面程序的输出结果为：

6．阅读下面程序，写出输出结果。 #include using namespace std; class Point { public: Point (int x = 0, int y = 0): m_x(x), m_y(y){ } int GetX() const { return m_x; } int GetY() const { return m_y; } void SetX(int x) { m_x = x; } void SetY(int y) { m_y = y; } private: int m_x; // X坐标 int m_y; // X坐标 };

int main(void)

{ Point oPoint1; const Point oPoint2(3, 4); cout << oPoint1.GetX() << endl;

oPoint1.SetX(1); cout << oPoint1.GetX() << endl; oPoint1.SetY(2); cout << oPoint1.GetY() << endl; cout << oPoint2.GetX() << endl; cout << oPoint2.GetY() << endl; return 0;

}上面程序的输出结果为：

7. 阅读下面程序，写出输出结果。 #include class Sample { int i; public: Sample(); void Display( ); ~Sample(); };

Sample::Sample()

{ cout << \ i=0; }

void Sample::Display() { cout << \Sample::~Sample() { cout << \int main()

{ Sample a; a.Display(); return 0;

}上面程序的输出结果为：

8．阅读下面程序，写出输出结果。 #include using namespace std; class A { int a,b; public: A() { a = b = 0; } A(int aa, int bb) { a = aa; b = bb; cout << a << ' ' << b << endl; } };

int main()

{ A x, y(2,3); return 0;

}上面程序的输出结果为：

六、 编程题（本大题共2小题，每小题10分，共20分） 1．设计一个类DateInfo，要求其满足下述要求：

（1）要求有一个无参的构造函数，其初始的年、月、日分别为：2010，6，8。 （2）要求有一个带参数的构造函数，其参数分别对应年、月、日。 （3）要求用一个成员函数实现日期的设置。 （4）要求用一个成员函数实现输出日期。 要求用一个成员函数实现日期的获取。 2．定义一个复数类Complex, 二个数据成员为double型r, i 为private属性。定义代二个参数的构造函数和一个Show( ) 函数用以输出r, i的值, 另外作为成员函数重载的运算苻”+”的功能是将此类二个对象的数据成员r和i对应相加。这些成员函数的属性均为public. 请用C++编写此程序, 并编写测试程序进行测试。

C++面向对象程序设计模拟试题六

一、单项选择题（本大题共15小题，每小题2分，共30分）在每小题列出的四个备选项中，只有一个是苻合题目要求的。请将其代码填写在题后的括号内。错选，多选或未选均无分。 1．类的析构函数的作用是( )。 A) 作为类的一般成员函数 B) 类的初始化 C) 对象的初始化 D) 对象的删除 2．一个类的友元函数或友元类可以访问该类的( )。A) 私有成员 B) 保护成员 C) 公有成员 D) 所有成员

3．下列关于成员函数特征的描述中，( ) 是错误的。A) 成员函数一定是内联函数 B) 成员函数可以重载 C) 成员函数可以设置参数的默认值 D) 成员函数可以是静态的

4．下列函数中，( ) 不是类的成员函数。A) 构造函数 B) 析构函数 C) 友元函数 D) 拷贝构造函数 5．下列对派生类的描述中，( ) 是错误的。 A) 一个派生类可以作为另一个派生类的基类 B) 派生类至少有一个基类 C) 派生类的成员除了它自己的成员外, 还包含了它的基类的成员 D) 派生类中继承的基类成员的访问权限到派生类中保持不变

6．下列的描述中，( ) 是错误的。A) 公有继承时基类中的public成员在派生类中仍是public的 B) 公有继承时基类中的private成员在派生类中仍是private的 C) 公有继承时基类中的protected成员在派生类中仍是protected的

D) 私有继承时基类中的public成员在派生类中仍是private的 7．下列虚基类的声明中正确的是( )。

A) class virtual B: public A B) virtual class B: public A

C) class B: public A virtual D) class B: virtual public A 8．若类A和类B的定义如下： class A

{ int i, j; public: A(int m, int n): i(m), j(n) {} int Geti() { return i;} };

class B: public A { int k; public: B(int m, int n, int u): A(m, n), k(u) {} void Make() { k = i * j; } };

int main()

{ B b(1, 2, 3); return 0;

}则上述定义中，( ) 是非法的表达式.A) k=i*j; B) int k; C) return i; D) void Make( ) 9．若有以下程序: #include using namespace std; class A { public: int a; A() { a =10; } };

class A1: public A1． { public: A1() { a = a + 1; } \\ };

class A2: public A { public: A2() { a = a + 2; } };

class B: public A1, public A2 { public: B() {} void Print() { cout << a << endl; } };

int main() { B obj; obj.Print(); return 0;

}则程序运行后的输出结果为：A) 产生语法错误 B) 13 C) 12 D)10

10．在下面的4个关键字中，( ) 是用来说明虚函数的。A) virtual B)public C)protected D)private 11．实现运行时的多态要使用( )。A) 重载函数 B) 析构函数 C) 构造函数 D) 虚函数

12．如果一个类至少有一个纯虚函数, 那么该类称为( )。A) 抽象类 B) 虚基类 C) 派生类 D) 以上都不对 13．cin是某个类的标准对象，该类是（ ）。A) ostream B) istream C) stdout D) stdin 14．调用一个成员函数时，使用动态联编的情况是（ ）。

A) 通过对象调用一虚函数 B) 通过指针或引用调用一虚函数 C) 通过对象调用一静态函数 D) 通过指针或引用调用一静态函数

15．假定CTest为一个类，并且有一无默认值的有参构造函数和一无参构造函数，则执行“CTest objTest;”语句时将自动调用该类的（ ）。 A) 有参构造函数 B) 无参构造函数 C) 拷贝构造函数 D) 赋值重载函数 二、判断正误题(本大题共5小题,每小题2分,共10分)

1．在用class定义一个类时, 数椐成员和成员函数默认的访问权限是public。

2．若类Y是类X的私有派生类, 类Z是类Y的公有派生类, 则类Z不能访向类X的公有成员和保护成员。 3．C++中设置虚基类的目的是实现运行时的多态。 4．模板类与类模板的意义完全相同。 5．只有常成员函数才可以操作常对象。

三、填空题(本大题共5小题,每小题2分,共10分) 1．类的具体表现是通过创建 来操作的。 2．假定AB为一个类，则执行“AB a[10]；”语句时，系统自动调用该类的构造函数的次数为 。 3．使用函数模板的方法是先说明函数模板，然后实例化成相应的 进行调用 执行。 4．拷贝构造函数用它所在类的 作为参数。 5．重载运算符“<<”的函数名为 。

四、程序分析题(本大题共8小题,每小题3分,共24分)给出下面各程序的输出结果。 1．若有以下程序: #include class A { int a;

public:A(int aa = 0 ) { a = aa; cout << \ } };

class B: public A { int b; public: B(int aa = 0, int bb = 0): A(aa) { b = bb; cout << \ } };

int main()

{ B x(5), y(6,7); return 0; }输出结果为:

2．若有以下程序: #include class Point { int x, y; public: Point(int m = 0, int n = 0) { x = m; y = n; } void Show() { cout << \ };

int main( )

{ Point *p = new Point(1, 68); p->Show(); delete p; return 0; }输出结果为:

3．若有以下程序: #include class Sample { int n; public: Sample(int i) { n = i; s += n; } static int s; void Show() { cout << s << endl; } };

int Sample::s = 0; int main()

{ Sample a(2), b(5), c(8); c.Show(); return 0; }输出结果为:

4．若有以下程序: #include class Sample { int n; public: Sample(int i) { n = i; } void Print() { cout << \ void Print( ) const { cout << \ };

int main()

{ Sample a(10); const Sample b(20); a.Print(); b.Print(); return 0; }输出结果为:

5．若有以下程序: #include class Test { int x; public: void Setx(int i) { x = i; } int Putx() { return x; } };

int main() { Test *p; Test a[3]; a[0].Setx(5); a[1].Setx(6); a[2].Setx(7); for( int j = 0; j < 3; j++) { p = &a[j]; cout << p->Putx() << \ } cout << endl; return 0; }出结果为:

6．若有以下程序: #include class Base {public: Base(int x) { a = x; } void Show() { cout << a << endl; }

private: int a; };

class Derived: public Base {public: Derived (int i): Base(i + 1), b(i) {} void Show() { cout << b << endl; } private: int b; };

int main()

{ Base b(5), *pb; Derived d(1); pb = &d; pb->Show(); return 0; }输出结果为:

7．若有以下程序: #include class Base {public: void Fun() { cout << \};class Derived: public Base {public: void Fun() { cout << \};

int main()

{ Derived a; Base *p; p = &a; (*p).Fun(); a.Fun(); return 0; }输出结果为:

8. 下列程序的输出结果为 #include template class FF

{ TT a1,a2,a3; public: FF(TT b1,TT b2, TT b3) { a1 = b1; a2 = b2; a3 = b3; } TT Sum() { return a1 + a2 + a3; } };

int main()

{ FF x(2, 3, 4), y(5, 7, 9); cout << x.Sum( ) <<' ' << y.Sum() << endl; return 0; }输出结果为:

六、 编程题（本大题共2小题，每小题10分，共20分） 1．设计一个类Rect，要求如下：

（1）该类中的私有数据成员length，width存放它的长和宽,并且设置它们的默认值是0。 （2）通过成员函数设置其长和宽，并确保长和宽都在(0，50)范围之内。 （3）实现求周长函数GetPerimeter()。

2．定义一个二维座标类Vector2d, 二个数据成员为double型x, y 为private属性。定义代二个参数的构造函数和一个Show( ) 函数用以输出x, y的值, 另外作为成员函数重载的运算苻”+”的功能是将此类二个对象的数据成员x和y对应相加。这些成员函数的属性均为public. 请用C++编写此程序, 并编写测试程序进行测试

C++面向对象程序设计模拟试题七

一、选择题（每小题2分，共40分） 1、C++是（ ）。 A. 面向对象的程序设计语言 B. 面向过程的程序设计语言

C. 既支持面向对象的程序设计又支持面向过程的程序设计的混合型语言 D. 非结构化的程序设计语言 2、面向对象程序设计思想的主要特征中不包括（ ）。

A. 封装性 B. 多态性 C. 继承性 D. 功能分解，逐步求精 3、若定义：string str; 当语句cin>>str; 执行时，从键盘输入： Microsoft Visual Studio 6.0! 所得的结果是str=（ ）。A. Microsoft Visual Studio 6.0! B. Microsoft C. Microsoft Visual D. Microsoft Visual Studio 6.0

4、考虑下面的函数原型声明：void testDefaulParam(int a,int b=7,char z='*'); 下面函数调用中，不合法的是（ ）。A. testDefaulParam(5); B. testDefaulParam(5,8); C. testDefaulParam(5,'#'); D. testDefaulParam(0,0,'*'); 5、下列语句中，将函数int sum(int x, int y)正确重载的是（ ）。 A. float sum(int x, int y); B. int sum(int a, int b); C. float sum(float x, float y); D. double sum(int y, int x); 6、下列表示引用的方法中，（ ）是正确的。

已知：int a=1000;A. int &x=a; B. char &y; C. int &z=1000; D. float &t=&a;

7、在一个函数中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用（ ）。 A. 内联函数 B. 重载函数 C. 递归调用 D. 嵌套调用 8、下列有关C++类的说法中，不正确的是（ ）。 A. 类是一种用户自定义的数据类型

B. 只有类中的成员函数或类的友元函数才能存取类中的私有成员 C. 在类中，如果不做特别说明，所有成员的访问权限均为私有的 D. 在类中，如果不做特别说明，所有成员的访问权限均为公用的

9、已知X类，则当程序执行到语句：X array[3];时，调用了（ ）次构造函数。A. 0 B. 1 C. 2 D. 3 10、下面说法中，正确的是（ ）

A. 一个类只能定义一个构造函数，但可以定义多个析构函数 B. 一个类只能定义一个析构函数，但可以定义多个构造函数

C. 构造函数与析构函数同名，只要名字前加了一个求反符号（~）

D. 构造函数可以指定返回类型，而析构函数不能指定任何返回类型，即使是void类型也不可以 11、已知：print( )函数是一个类的常成员函数，它无返回值，下列表示中，（ ）是正确的。

A. void print( ) const; B. const void print( ); C. void const print( ); D. void print(const); 12、下面描述中，表达错误的是（ ）

A. 公用继承时基类中的public成员在派生类中仍是public的 B. 公用继承时基类中的private成员在派生类中仍是private的 C. 公用继承时基类中的protected成员在派生类中仍是protected的 D. 私有继承时基类中的public成员在派生类中是private的 13、设置虚基类的目的是（ ）。A. 简化程序 B. 消除二义性 C. 提高运行效率 D. 减少目标代码 14、下面（ ）的叙述不符合赋值兼容规则。

A. 派生类的对象可以赋值给基类的对象B. 基类的对象可以赋值给派生类的对象

C. 派生类的对象可以初始化基类的对象D. 派生类的对象的地址可以赋值给指向基类的指针 15、关于虚函数的描述中，（ ）是正确的。

A. 虚函数是一个static类型的成员函数 B. 虚函数是一个非成员函数

C. 基类中说明了虚函数后，派生类中与其对应的函数可不必说明为虚函数 D. 派生类的虚函数与基类的虚函数具有不同的参数个数和类型 16、下面关于友元的描述中，错误的是（ ）。 A. 友元函数可以访问该类的私有数据成员

B. 一个类的友元类中的成员函数都是这个类的友元函数

C. 友元可以提高程序的运行效率D. 类与类之间的友元关系可以继承 17、下列关于静态数据成员的说法，不正确的是（ ）。 A. 类中定义的公用静态数据成员，可以通过类的对象来访问 B. 类中定义的所有静态数据成员，都必须在类外初始化

C. 静态数据成员不是所有对象所共用的D. 普通的成员函数可以直接访问类中的静态数据成员

18、如果表达式++i*k中的“++”和“*”都是重载的友元运算符，若采用运算符函数调用格式，则表达式还可以表示为（ ）。

A. operator*(i.operator++(),k) B. operator*(operator++(i),k)

C. i.operator++().operator*(k) D. k.operator*(operator++(i)) 19、下面对模板的声明，正确的是（ ）。A. template B. template C. template D. template 20、下列的各类函数中，（ ）不是类的成员函数A. 构造函数 B. 析构函数 C. 友元函数 D. 复制构造函数 二、填空题（前14个空，每空1分，后3个空，每空2分，共20分）

1、类和对象的关系可表述为：类是对象的 ，而对象则是类的 。

2、静态成员函数没有隐含的 ，所以，在C++程序中，静态成员函数主要用来访问静态数据成员，而不访问非静态成员。

3、在图1中，A，B，C，D，E，F均是类，其中属于单继承的派生类有 ，属于多继承的派生类有 ，类F的基类有 ，类A的派生类有 。

A D B C E F

4、如果只想保留公共基类的一个复制，就必须使用关键字 把这个公共基类声明为虚基类。 5、从实现的角度来讲，多态性可以划分为两类： 和 。 6、如果一个类包含一个或多个纯虚函数，则该类称为 。

7、若要把void fun()定义为类A的友元函数，则应在类A的定义中加入语句 。 8、列出C++中的两种代码复用方式： 和 。

9、析构函数的作用是 。 10、假定A是一个类名，则该类的拷贝构造函数的原型说明语句为： 。

11、后置自增运算符“++”重载为类的成员函数（设类名为A）的形式为： 。 三、阅读下面4个程序，写出程序运行时输出的结果。（共13分） 1、

#include using namespace std; void fun(int &a, int &b) { int p;

p=a; a=b; b=p; }

void exchange(int &a, int &b, int &c) { if( a

int main()

{ int a=12,b=89,c=56; exchange(a, b, c);

cout<<\ return 0; } 2、

#include using namespace std; class A { public:

A( ) { cout << \};

class B { public:

B( ) { cout <<\ };

class C: public A { public:

C( ) { cout << \private:

图1 类的继承层次图

B b; };

int main ( ) { C obj; return 0; } 3、

#include using namespace std; class A {public:

A(){cout<<\

virtual ~A(){cout<<\};

class B: public A {public: B(int i)

{ cout<<\ buf=new char[i]; }

virtual ~B()

{ delete []buf; cout<<\}

private: char *buf; };

int main()

{ A *a=new B(15); delete a; return 0; } 4、

#include using namespace std; class A {public: void f(){cout<<\ };

class B {public: void f() {cout<<\ void g() {cout<<\ };

class C: public A, public B {public: void g(){cout<<\ };

int main() { C cc; cc.B::f(); cc.B::g(); cc.g(); return 0;

}四、编程题（27分） 1、（10分） 已知复数类Complex的声明如下： class Complex {public:

Complex(); //无参构造函数 Complex(double ); //转换构造函数 Complex(double, double); //有两个形参的构造函数

friend Complex operator+(Complex&, Complex&); //对“+”运算符进行重载

friend ostream& operator<<(ostream&, Complex&); //对“<<”运算符进行重载 friend istream& operator>>(istream&, Complex&); //对“>>”运算符进行重载 private:

double real,imag; };要求：（1）写出该类的所有构造函数的类外定义代码。 （2）写出对运算符“+”、“<<”、“>>”进行重载的运算符重载函数的定义。 2、（17分）下列Shape类是一个表示形状的抽象类，area( )为求图形面积的函数，total( )则是一个通用的用以求不同形状的图形面积总和的函数。 class Shape

{public: virtual double area()=0;}; double total(Shape *s[ ], int n) { double sum=0.0;

for(int i=0; iarea( ); return sum; }要求：（1）从Shape类派生圆类(Circle)、正方形类（Square），圆类新增数据成员半径（radius），正方形类新增数据成员边长（a），圆类和正方形类都有构造函数，修改、显示数据成员值的函数，求面积函数。

（2）写出main()函数，计算半径为5.5的圆和边长为9.9的正方形的面积和（必须通过调用total函数计算）。

C++面向对象程序设计模拟试题八

一、单项选择题（每小题2分，共40分） 1、关于C++与C语言关系的描述中，（ ）是错误的。

A．C语言是C++语言的一个子集 B．C语言与C++语言是兼容的

C．C++语言对C语言进行了一些改进 D．C++语言和C语言都是面向对象的 2、已知：int m=10; 下列表示引用的方法中，（ ）是正确的。

A．int &x=m; B．int &y=10; C．int &z; D．float &t=&m; 3、考虑下面的函数原型声明：void testDefaulParam(int a,int b=7,char z='*'); 下面函数调用中，不合法的是（ ）。A．testDefaulParam(5); B．testDefaulParam(5,8); C．testDefaulParam(5,'#'); D．testDefaulParam(0,0,'*');

4、系统在调用重载函数时往往根据一些条件确定哪个重载函数被调用，在下列选项中，不能作为依据的是（ ）。 A．函数的返回值类型 B．参数的类型 C．函数名称 D．参数个数 5、下列有关C++类的说法中，不正确的是（ ）。 A．类是一种用户自定义的数据类型

B．只有类中的成员函数或类的友元函数才能存取类中的私有成员 C．在类中，如果不做特别说明，所有成员的访问权限均为私有的 D．在类中，如果不做特别说明，所有成员的访问权限均为公用的

6、已知X类，则当程序执行到语句X array[3];时，调用了（ ）次构造函数。A．0 B．1 C．2 D．3 7、有关析构函数的说法，不正确的是（ ）。

A．析构函数有且仅有一个B．析构函数和构造函数一样可以有形参

C．析构函数的功能是在系统释放对象之前作一些内存清理工作D．析构函数无任何函数类型 8、类定义的内容允许被其对象无限制地存取的是（ ）。

A．private 部分 B． protected 部分 C．public 部分 D．以上都不对 9、关于常数据成员的说法，不正确的是（ ）。

A．常数据成员的定义形式与一般常变量的定义形式相同，只不过常数据成员的定义必须出现在类体中

B．常数据成员必须进行初始化，并且不能被更新C．常数据成员通过构造函数的成员初始化列表进行初始化 D．常数据成员可以在定义时直接初始化

10、运用运算符delete删除一个动态对象时（ ）。

A．系统首先为该动态对象调用构造函数，再释放其占用的内存 B．系统首先释放该动态对象占用的内存，再为其调用构造函数 C．系统首先为该动态对象调用析构函数，再释放其占用的内存 D．系统首先释放动态对象占用的内存，再为其调用析构函数

11、可以在类外用p.a的形式访问派生类对象p的基类成员a，其中a是（ ）。

A．私有继承的公用成员 B．公用继承的私有成员C．公用继承的保护成员 D．公用继承的公用成员 12、在公用继承方式下，有关派生类对象和基类对象的关系，不正确的叙述是（ ）。 A．派生类的对象可以赋给基类的对象B．派生类的对象可以初始化基类的引用

C．派生类的对象可以直接访问基类中的成员D．派生类的对象的地址可以赋给指向基类的指针 13、设置虚基类的目的是（ ）。A．简化程序 B．消除二义性 C．提高运行效率 D．减少目标代码 14、在C++中，用于实现动态多态性的是（ ）。A．内联函数 B．重载函数 C．模板函数 D．虚函数 15、不能说明为虚函数的是（ ）。A．析构函数 B．构造函数 C．类的成员函数 D．以上都不对 16、如果一个类至少有一个纯虚函数，那么就称该类为（ ）。

A．抽象类 B．派生类 C．纯基类 D．以上都不对 17、下面关于友元的描述中，错误的是（ ）。

A．友元函数可以访问该类的私有数据成员B．一个类的友元类中的成员函数都是这个类的友元函数 C．友元可以提高程序的运行效率D．类与类之间的友元关系可以继承 18、下列运算符中，（ ）运算符在C++中不能被重载。A．&& B．[] C．:: D．new 19、模板的使用实际上是将类模板实例化成一个（ ）。

A．函数 B．对象 C．类 D．抽象类

20、假定MyClass为一个类，则该类的拷贝构造函数的声明语句为（ ）。 A．MyClass(MyClass x) B．MyClass&(MyClass x) C．MyClass(MyClass &x) D．MyClass(MyClass *x)

二、填空题（前16个空，每空1分，后2个空，每空2分，共20分）

1、类和对象的关系可表述为：类是对象的 ，而对象则是类的 。

2、在C++中，三种继承方式的说明符号为 、 和 ，如果不加说明，则默认的继承方式为 。

3、如果只想保留公共基类的一个复制，就必须使用关键字 把这个公共基类声明为虚基类。

4、若要把void fun()定义为类A的友元函数，则应在类A的定义中加入语句 。 5、类的静态成员分为 和 。

6、运算符重载要求保持其原来的操作数个数、 、 和语法结构。

7、通过关键字 可以声明模板，通过关键字 指定函数模板的类型参数，有几个类型参数就有几个类型关键字。

8、列出C++中两种用户自定义的数据类型： 、 。

9、构造函数的作用是 。

10、后置自增运算符“++”重载为类的成员函数（设类名为A）的形式为 。 三、阅读下面3个程序，写出程序运行时输出的结果：（共13分） 1、#include using namespace std; void fun(int &a,int &b) { int p;

p=a; a=b; b=p; }

void exchange(int &a,int &b,int &c) { if(a

int main()

{ int a=12,b=89,c=56; exchange(a,b,c);

cout<<\ return 0; }

2、#include using namespace std; class Date {public:

Date(int,int,int); Date(int,int); Date(int); Date();

void display(); private:

int month, day, year;

}; Date::Date(int m,int d,int y):month(m),day(d),year(y) { } Date::Date(int m,int d):month(m),day(d) {year=2009;} Date::Date(int m):month(m){day=1; year=2010; } Date::Date() {month=1; day=1; year=2010; }

void Date::display(){cout<

{ Date d1(12,31,2009); Date d2(12,31); Date d3(1); Date d4; d1.display(); d2.display(); d3.display(); d4.display(); return 0; } 3、#include using namespace std; class A

{ public: A(){cout<<\ ~A(){cout<<\class B: public A

{ public: B(){cout<<\ ~B(){cout<<\class C : public B

{ public: C(){cout<<\

~C(){cout<<\int main()

{ C c1; return 0; }

四、编程题（共27分） 1、（10分） 已知复数类Complex的声明如下： class Complex {public:

Complex(); //无参构造函数 Complex(double ); //转换构造函数 Complex(double, double);//有两个形参的构造函数

friend Complex operator+(Complex&, Complex&); //对“+”运算符进行重载 friend ostream& operator<<(ostream&, Complex&); //对“<<”运算符进行重载 friend istream& operator>>(istream&, Complex&); //对“>>”运算符进行重载 private:

double real,imag; };要求：（1）写出该类的所有构造函数的类外定义代码。 （2）写出对运算符“+”、“<<”、“>>”进行重载的运算符重载函数的定义。 2、（17分）下列Shape类是一个表示形状的抽象类，area( )为求图形面积的函数，total( )则是一个通用的用以求不同形状的图形面积总和的函数。 class Shape

{public: virtual double area()=0; };double total(Shape *s[ ], int n) { double sum=0.0;

for(int i=0; iarea( ); return sum; }要求：（1）从Shape类派生圆类(Circle)、正方形类（Square），圆类新增数据成员半径（radius），正方形类新增数据成员边长（a），圆类和正方形类都有构造函数，修改、显示数据成员值的函数，求面积函数。

（2）写出main()函数，计算半径为5.5的圆和边长为9.9的正方形的面积和（必须通过调用total函数计算）。

C++面向对象程序设计模拟试题一参考答案

一、单项选择题1．B 2．A 3．A 4．C 5．C 6．D 7．D 8．D 9．A 10．A

二、1．参考答案：√2．参考答案：×3．参考答案：×4．参考答案：×5．参考答案：√6．参考答案：√ 三、填空题1．参考答案：new2．参考答案：class或typename3．参考答案：重载4．参考答案：对象 5．参考答案：静态6．参考答案：operator+ 四、1．参考答案：9 7 2 1 5

2．参考答案：5 6 8 6.8 9.6 3．参考答案：6 1 8 2 2 4．参考答案：0 0 1 6 18

六、编程题（本大题共2个小题，每小题8分，共16分） 1．参考程序： #include using namespace std; template Type Abs(Type tVar) { if (tVar >= 0) return tVar; else return -tVar; }

int main() { cout << Abs(5) << endl; cout << Abs(-5) << endl; cout << Abs(2.5) << endl; cout << Abs(-2.5) << endl; return 0; }

2．参考程序： #include using namespace std;

class CComplex {

public: CComplex(double dReal, double dImage = 0) { m_dReal = dReal; m_dImage = dImage; } void Show() { cout << m_dReal; if (m_dImage > 0) { cout << \ } else if(m_dImage < 0) { cout << \ } } CComplex operator+(const CComplex &obj) { CComplex objTemp(m_dReal + obj.m_dReal, m_dImage + obj.m_dImage); return objTemp; } private: double m_dReal, m_dImage; };

int main() { CComplex obj1(2, 6), obj2(3, 8), obj3(0); obj1.Show(); obj2.Show(); obj3.Show(); obj3 = obj1 + obj2; obj3.Show(); return 0; }

参考答案二

一、判断题（每题2分共12＊2=24分） 1 2 3 4 5 6 7 8 9 10 题目 答案 × × √ × × × √ √ × × 11 × 12 √ 二、读程题，写出程序的运行结果。（共28分） 1、1 4 7 2、 28 3、 ff(double):88.18 ff(int):97 4、Constructor Copy_ Constructor A=3,B=5 Constructor A=5,B=6 Destructor Destructor Destructor 三、编程题（每题10分，共10×2=20分） 1、#include int prime(int x); void main() { int sum=0;

for(int i=51;i<100;i+=2) sum+=prime(i);

cout<<\}

int prime(int x) { for(int j=2;j=x) return x; else return 0; }

2、#include void main() { for (int i=1;i<=5;i++) { for (int j=1;j<=i;j++) cout<

四、综合分析应用题（共28分） 1、（简答）格式： 1）、传值：实参用变量名（或常数），形参用变量名； 2）、传址：实参用地址，形参指针； 3）、引用：实参用变量名，形参用引用；

传值调用：是单向的，实参把值拷贝一份给形参，形参值的改变不会影响实参；传址调用：是双向的，把实参的地址传给形参，形参就指针了实参变量，因此形参的改变会影响实参；引用调用：形参是实参的别名，形参的改变也肢影响实参，注意，实参只能用变量名，不能用常量！ 代码：（略） 2、（简答）：int x, *px=&x;// 定义指向普通常量的指针 int arr[5]={1,2,3,4,5},*pa=a;// 定义指向一维数组的指针 myclass object,*pobj=&object; // 定义指向对象的指针 假设类A中有公有数据成员：int c;

假设类A中有公有成员函数：int fun(int b); 则

int A::*pc=&A::c; // 定义指向类的数据成员的指针;

int (A::*pfun)(int)=A::fun; // 定义指向类的成员函数的指针; 3、（略）

C++面向对象程序设计模拟试题三参考答安全

一、单项选择题1．C 2．D 3．A 4．B 5．D 6．A 7．C 8．C 9．C 10．A 二、填空题1．参考答案：int fun() = 0;

2．参考答案：static3．参考答案：CTest 4．参考答案：构造函数 5．参考答案：private或私有 三、完成程序填题1．参考答案：[1]static

2．参考答案：[2] a + i.a或this->a + i.a 3．参考答案：[3] char * 四、程序分析题

1．参考答案：0 5 18 9 98 2．参考答案：8 2 3 4 5

3．参考答案：构造A 构造B 构造A 析构B 析构A 4．参考答案： 15.3 1 2 1.1 2.2

六、编程题（本大题26分） 参考程序：

#include // 预处理命令 using namespace std; // 使用标准命名空间std const double PI = 3.1415926; // 定义常量PI class Shape {public: Shape() { } // 构造函数 virtual ~Shape() { } // 析构函数 virtual Show() = 0; // 显示面积 static double totalArea; // 总面积 static void ShowTotalArea() { cout << \总面积:\};

class Circle: public Shape {private: double radius; // 半径 public:

Circle(double r): radius(r) { totalArea += PI * r * r; } // 构造函数 ~Circle() { } // 析构函数 virtual Show() { cout << \圆面积:\ // 显示面积 };

class Rectangle: public Shape {private: double length; // 长 double width; // 宽 public: Rectangle(double l, double w): length(l), width(w){ totalArea += l * w; } // 构造函数 ~Rectangle() { } // 析构函数 virtual Show() { cout << \矩形面积:\ // 显示面积 };

double Shape::totalArea = 0; // 初始化totalArea int main(void) { Circle c(1); // 定义圆对象 c.Show(); // 显示面积 Rectangle r(1, 2); // 定义矩形对象 r.Show(); // 显示面积 Shape::ShowTotalArea(); // 显示总面积 return 0; // 返回值0, 返回操作系统 }

C++面向对象程序设计模拟试题四参考答巡查

一、单项选择题1．C 2．C 3．C 4．A 5．C6．A 7．B 8．D 9．A 10．A

二、填空题1．参考答案：基类2．参考答案：template3．参考答案：bool或布尔型4．参考答案：对象5．参考答案：析构函数 三、完成程序填题（本大题共3个小题，每小题3分，共9分）下面程序都留有空白，请将程序补充完整， 1．参考答案：[1]a(x)2．参考答案：[2]operator int

3．参考答案：[3] realPart + a.realPart, imagePart + a.imagePart或this->realPart + a.realPart, this->imagePart + a.imagePart 四、程序分析题（本大题共4小题，每小题5分，共20分）给出下面各程序的输出结果。 1．参考答案：Class A Class B Class A Class B Class B

2．参考答案：1 6 9 1 6 3．参考答案：1 2 3 4 3

4．参考答案：A() B() B::f() ~B() ~A()

六、编程题（本大题26分） 参考程序：

#include // 预处理命令 using namespace std; // 使用标准命名空间std const double PI = 3.1415926; // 定义常量PI class Shape {public: Shape() { } // 构造函数 virtual ~Shape() { } // 析构函数 virtual ShowArea() = 0; // 显示面积 static double totalArea; // 总面积 static void ShowTotalArea() { cout << \总面积:\};

class Circle: public Shape {private: double radius; // 半径 public: Circle(double r): radius(r) { totalArea += PI * r * r; } // 构造函数 ~Circle() { } // 析构函数 virtual ShowArea() { cout << \圆面积:\// 显示面积 };

class Rectangle: public Shape {private: double length; // 长 double width; // 宽 public: Rectangle(double l, double w): length(l), width(w){ totalArea += l * w; } // 构造函数 ~Rectangle() { } // 析构函数 virtual ShowArea() { cout << \矩形面积:\// 显示面积 };

class Square: public Shape {private: double length; // 边长 public: Square(double l): length(l){ totalArea += l * l; } // 构造函数 ~Square() { } // 析构函数 virtual ShowArea() { cout << \正方形面积:\显示面积 };

double Shape::totalArea = 0; int main(void) { Circle c(1); c.ShowArea(); Rectangle r(1, 2); r.ShowArea(); Square z(3); z.ShowArea(); Shape::ShowTotalArea(); return 0; }

// 初始化totalArea

// 定义圆对象 // 显示面积 // 定义矩形对象 // 显示面积 // 定义正方形对象 // 显示面积 // 显示总面积

// 返回值0, 返回操作系统

一、单项选择题1．A） 2．B） C++面向对象程序设计模拟试题五参考答案

3．C) 4．C） 5．A)6．D) 7．C) 8．B) 9．A) 10．C) 11．D) 12．D) 13．B)

14．C) 15．A)

二、判断正误题1．参考答案：“√” 2．参考答案：“×”3．参考答案：“×”4．参考答案：“×”5．参考答案：“×” 三、 填空题1．参考答案：oprator-

2．参考答案：继承3．参考答案：pb=&b 4．参考答案：重载5．参考答案：delete

四、程序分析题（本大题共8小题，每小题3分，共24分）给出下面各程序的输出结果。 1．输出结果为：Destructor B! 7 Destructor A! 6 Destructor B! 0 Destructor A! 5 2．输出结果为: x=5, y=12

3．输出结果为: 7 4．输出结果为:1 2

5．输出结果为:d=88i=88 6．程序的输出结果为：0 1 2 3 4

7．程序的输出结果为：constructor,i=0,destructor 8．程序的输出结果为：2 3

六、 编程题（本大题共2小题，每小题10分，共20分） 1．参考程序： #include using namespace std; class DateInfo { private: int year, month, day; public: DateInfo(): year(2010), month(6), day(8){ } DateInfo(int y, int m, int d): year(y), month(m), day(d){ } void Set(int y, int m, int d) { year = y; month = m; day = d; } void Show() { cout << year << \年\月\日\};

int main() { DateInfo d1, d2(1988, 8, 18); d1.Show(); d2.Show(); d2.Set(1999, 9, 19); d2.Show(); return 0; }

2．参考程序： #include using namespace std; class Complex { private: double r, i; public: Complex(double a, double b): r(a), i(b) {} void Show() { cout << r << \ \ Complex operator +(Complex obj) { return Complex(r + obj.r, i + obj.i); } };

int main() { Complex c1(3.5, 4.5), c2(2.5, 5.5), c3(0.0, 0.0); c3 = c1 + c2; c3.Show(); return 0; }

C++面向对象程序设计模拟试题六参考答案

一、单项选择题 1．D) 2．D) 3．A) 4．C) 5．D)6．B) 7．D) 8．A） 9．A) 10．A).11．D) 12．A) 14．B) 15．B) 二、判断正误题 1．参考答案：“×”2．参考答案：“×”3．参考答案：“√”4．参考答案：“×”5．参考答案：“√” 三、 填空题

1．参考答案：对象2．参考答案：10 3．参考答案：模板函数4．参考答案：引用5．参考答案：operator <<

13．B)

四、程序分析题（本大题共8小题，每小题3分，共24分）给出下面各程序的输出结果。 1．输出结果为：A(): 5 B(): 0 A(): 6 B(): 7

2．输出结果为: x=1, y=68 3．输出结果为: 15 4．输出结果为:1:n=10,2:n=20 5．输出结果为:5,6,7 6．程序的输出结果为：2 7．程序的输出结果为：1 2 8．程序的输出结果为：9 21

六、 编程题（本大题共2小题，每小题10分，共20分） 1．参考程序： #include using namespace std; class Rect { private: double length, width; public: Rect(double l = 0, double w = 0): length(l), width(w){ } void Set(double l, double w) { if (length <= 0 || length >= 50 || width <= 0 || width >= 50 ) throw \数据不在指定范围(0,50)!\ // 抛出异常 length = l; width = w; } double GetPerimeter() { return 2 * (length + width); } };

int main() { try // 检查异常 { Rect obj(1, 8); cout << \周长:\ } catch (char *str) // 捕捉异常 { // 处理异常 cout << \异常信息:\ // 输出异常信息 } return 0; }

2．参考程序： #include using namespace std; class Vector2d { double x, y; public: Vector2d(double a, double b): x(a), y(b) {} void Show() { cout << x << \ \ Vector2d operator+(Vector2d &obj); };

Vector2d Vector2d::operator+(Vector2d &obj) { return Vector2d(x + obj.x, y + obj.y); } int main() { Vector2d d1(3.5, 4.5), d2(2.5, 5.5), d3(0.0, 0.0); d3 = d1 + d2; d3.Show(); return 0;

}C++面向对象程序设计模拟试题七参考答案

一、单项选择题1-5．C D B C C 6-10．A A D D B 11-15．A B B B C 16-20．D C B C C 二、填空题（前14个空，每空1分，后3个空，每空2分，共20分）

1． 抽象 实例 2． this指针

3． E D、F A、B、C、D、E D、F 4． virtual 5． 静态多态性 动态多态性 6. 抽象类 7. friend void fun(A &a) 8. 继承 组合或模板

9. 在对象被系统释放之前做一些内存清理工作 10. A(const A&) 11. A operator++(int) 三、阅读程序（13分） 1、a=89,b=56,c=12 2、ABC

3、A::A() called. B::B() called. B::~B() called. A::~A() called.

4、Call B's function f() Call B's function g() Call C's function g() 四、编程题（共27分） 1、（10分）

Complex::Complex(){real=0;imag=0;} Complex::Complex(double r){real=r;}

Complex::Complex(double r,double i){real=r;imag=i;} Complex operator+(Complex &c1,Complex &c2) { Complex c;

c.real=c1.real+c2.real; c.imag=c1.imag+c2.imag; return c; }

ostream& operator << (ostream& output,Complex& c) { output<<\ return output; }

istream& operator >> (istream& input,Complex& c)

{ cout<<\

input>>c.real>>c.imag; return input; } 2、（17分）

class Circle:public Shape {public:

Circle(double r){radius=r;} void set() { cout<<\ cin>>radius; }

void show() { cout<<\} double area() {return 3.14159*radius*radius;} private: double radius; };

class Square:public Shape {public:

Square(double a){this->a=a;} void set() { cout<<\ cin>>a; }

void show() { cout<<\} double area(){return a*a;} private: double a; };

int main() { Circle C(5.5); C.show(); Square S(9.9); S.show(); Shape *s[]={&C,&S}; cout<<\ return 0; }

C++面向对象程序设计模拟试题八参考答案

一、单项1-5．D A C A D 6-10．D B C D C 11-15．D C B D B 16-20．A D C C C 二、填空题（前16个空，每空1分，后2个空，每空2分，共20分）

1． 抽象 、 实例 2． public 、 private _ ___、 protected 、 private _ ___ 3． virtual ___ 4． friend void fun(A &a) _ 5． 静态数据成员 、 静态成员函数 6． 结合性 、 优先级_ ___ 7． Template 、 class(或typename) 8． 类 、 结构体 ___ 9． 在创建对象时初始化对象的数据成员 ___ 10． A operator++(int) ___ 三、阅读程序（共13分） 1、a=89,b=56,c=12 2、12/31/2009 12/31/2009 1/1/2010 1/1/2010

3、constructing A constructing B constructing C destructing C destructing B destructing A

四、编程题（共27分） 1、（10分）

Complex::Complex(){real=0;imag=0;} Complex::Complex(double r){real=r;}

Complex::Complex(double r,double i){real=r;imag=i;} Complex operator+(Complex &c1,Complex &c2) { Complex c;

c.real=c1.real+c2.real; c.imag=c1.imag+c2.imag; return c; }

ostream& operator << (ostream& output,Complex& c) { output<<\ return output; }

istream& operator >> (istream& input,Complex& c)

{ cout<<\ input>>c.real>>c.imag; return input; } 2、（17分）

class Circle:public Shape {public:

Circle(double r){radius=r;} void set()

{ cout<<\ cin>>radius; }

void show() { cout<<\ double area() {return 3.14159*radius*radius;} private: double radius; };

class Square:public Shape {public:

Square(double a){this->a=a;} void set() { cout<<\ cin>>a; }

void show() { cout<<\} double area(){return a*a;} private: double a; };

int main() { Circle C(5.5); C.show(); Square S(9.9); S.show(); Shape *s[]={&C,&S}; cout<<\ return 0; }

}