C++复习题+答案

C++总复习题

一、单项选择题

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个参数

参考答案：1．B 2．A 3．A 4．C 5．C 6．D

8．D 9．A 10．A

7．D

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. privateB. public C. deleteD. 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）虚函数

参考答案：1．C 2．D 3．A 4．B 5．D 6．A 7．C

8．C 9．C 10．A

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）通过常对象可以调用任何不改变对象值的成员函数

参考答案：1．C 2．C 3．C 4．A 5．C6．A 7．B 8．D 9．A

10．A

1．下列对类的构造函数和析构函数描述正确的是（ ）。 A)构造函数可以重载，析构函数不能重载 B)构造函数不能重载，析构函数可以重载 C)构造函数可以重载，析构函数可以重载 D)构造函数不能重载，析构函数不能重载 2．在函数定义前加上关键字“inline”，表示该函数被定义为（ ）。 A）重载函数 B）内联函数 C）成员函数 D）普通函数

3．下面有关重载函数的说明中，（）是正确的。 A) 重载函数必须具有不同的返回值类型 B) 重载函数形参个数必须不同 C) 重载函数必须具有不同的形参列表 D) 重载函数名可以不同 4．下列有关类与对象的说法中，( ) 是不正确的。 A) 对象是类的一个实列 B) 任何一个对象只能属于一个具体的类 C) 一个类只能有一个对象 D) 类和对象的关糸和数椐类型与变量的关糸类似 5．已知: Print( )函数是一个类的常成员函数，它无返回值，下列表示中，正确的是 ( )。 A）void Print( ) const； B) const void Print( )； C) void const Print( )； D) void Print(const) 6．假定Myclass为一个类,那么下列的函数说明中( )为该类的析构函数。 A) void ～Myclass( ); B) ～Myclass( int n); C) Myclass( ); D) ～Myclass( ) 7．下面类的定义中有 ( ) 处错误。 class myclass {

int i=0; public:

void myclass( )｛｝; ~myclass(value);

} ; A) 1 B)2 C)3 D)4 8．说明虚函数的关键字是（）。A. inline B. virtual C. define D. static 9．cout是某个类的标准对象的引用，该类是（）。 A. ostreamB. istream C. stdout D. stdin 10．如果class类中的所有成员在定义时都没有使用关键字public、private或protected，则所有成员缺省定义为（）。 A. public B. protected C. private D．static 11．定义类模板时要使用关键字（）。 A. const B. new C. delete D. template 12一个类的所有对象共享的是（）。A. 私有数据成员 B. 公有数据成员 C. 保护数据成员 D. 静态数据成员

13．静态成员函数没有（）。A. 返回值 B. this指针 C. 指针参数 D. 返回类型 14．解决多重继承中二义性问题的方法有（）。 A. 只能使用作用域分辨操作符 B. 使用作用域分辨操作符或赋值兼容规则 C. 使用作用域分辨操作符或虚基类 D. 使用虚基类或赋值兼容规则

15．如果在类CTest的外面函数调用CTest::f( )；则函数f( )是类CTest的（）。 A. 静态成员函数 B. 非静态成员函数 C. 友元函数 D. 前面都不正确

参考答案：1．A）2．B）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．类的析构函数的作用是( )。

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; 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:

C) return i;

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) istreamC) stdout D) stdin

14．调用一个成员函数时，使用动态联编的情况是（）。 A) 通过对象调用一虚函数 B) 通过指针或引用调用一虚函数 C) 通过对象调用一静态函数 D) 通过指针或引用调用一静态函数

15．假定CTest为一个类，并且有一无默认值的有参构造函数和一无参构造函数，则执行“CTest objTest;”语句时将自动调用该类的（）。 A) 有参构造函数 B) 无参构造函数 C) 拷贝构造函数 D) 赋值重载函数

参考答案：1．D) 2．D) 3．A) 4．C) 5．D)6．B) 7．D) 8．A）9．A)10．A).11．D) 12．A)13．B) 14．B) 15．B)

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 VisualD.Microsoft Visual Studio 6.0

4、考虑下面的函数原型声明：void testDefaulParam(int a,int b=7,char z='*'); 下面函数调用中，不合法的是（）。

A.testDefaulParam(5); B.testDefaulParam(5,8);

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函数计算）。

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: };

class Square:public Shape {public:

Square(double a){this->a=a;}

void set() { }

cout<<\cin>>a; double radius;

void show()

{

cout<<\

}

double area(){return a*a;} private: }; int main() { }

Circle C(5.5); C.show(); Square S(9.9); S.show();

Shape *s[]={&C,&S};

cout<<\return 0; double a;

六简答题

1、阐述C＋＋中函数三种调用的方式实现机制、特点及其实参、形参的格式，最好用代码说明（10分）。 2、用代码举例说明如何定义指向普通常量的指针、指向一维数组的指针、指向对象的指针、指向类的数据成员的指针和指向类的成员函数的指针。（10分）

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; //定义指向类的成员函数的指针;

七完成程序填题

1．请完成下面的程序 #include // 预处理命令 using namespace std; // 使用标准命名空间std // 测试静态成员类 class Test {

private: [1] 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 [2] ; // 返回和 } };

// 显示对象

int main(void) { Integer a(2), b(3), c; c = a + b; cout << c << endl; return 0; }3．请完成下面的程序 #include using namespace std; template class A {private: ElemType a; public: A(ElemType x): a(x){ } void Show() const { cout << a << endl; } };

int main(void) { A< [3] > obj(\ obj.Show(); return 0; }

// 主函数main(void) // 定义整数对象 // 求和 // 显示和 // 返回值0, 返回操作系统

// 预处理命令

// 使用标准命名空间std

// 数据成员 // 构造函数

// 显示a之值

// 主函数main(void) // 定义对象 // 显示相关信息

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

1．参考答案：[1]static2．参考答案：[2] a + i.a或this->a + i.a 3．参考答案：[3] char *

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: Integer(int x = 0){ a = x; } // 构造函数 [2] () { return a; } // 类型转换函数(将类类型转换为整型) };

int main(void) // 主函数main(void) { Integer a = 6; // 定义整数对象 cout << a << endl; // 显示整数 return 0; // 返回值0, 返回操作系统 }

3．请完成下面的程序 #include // 预处理命令 using namespace std; // 使用标准命名空间std / 复数类

class Complex {private: double realPart; // 实部 double imagePart; // 虚部 public: Complex(double real = 0, double image = 0): realPart(real), imagePart(image){ } // 构造函数 double GetRealPart() const{ return realPart; } // 返回实部 double GetImagePart() const{ return imagePart; } // 返回虚部 Complex operator+(const Complex &a) const // 重载加法运算符+ { return Complex( [3] ); // 返回和 }};

int main(void) // 主函数main(void) { Complex a(1, 2), b(2, 6), c; // 定义复数对象 c = a + b; // 复数加法运算 cout << \// 显示a cout << \// 显示b cout << \// 显示c return 0; // 返回值0, 返回操作系统 }

1．参考答案：[1]a(x)2．参考答案：[2]operator int

3．参考答案：[3] realPart + a.realPart, imagePart + a.imagePart或this->realPart + a.realPart, this->imagePart + a.imagePart

{ 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; }

参考答案： 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

五、编程题

测试一个名为rectangle的矩形类，其属性为矩形的左下角与右上角两个点的坐标，能计算矩形的面积。(10分)

定义一boat与car两个类，二者都有weight属性，定义二者的一个友元函数totalweight()，计算二者的重量和。(10分)

设计一个汽车类vehicle，包含的数据成员有车轮个数wheels和车重weight。小车类car是它的派生类，其中包含载人数passenger_load。每个类都有相关数据的输出方法。在主程序中定义一个car类对象，对其车轮个数、车重、载人数进行设置并显示。(10分)

1、

#include #include class rectangle //(2分) { private:

int x1,y1,x2,y2; // (2分)

public:

rectangle(int xx1,int yy1,int xx2,int yy2) //(1分) { }

x1=xx1;y1=yy1;x2=xx2;y2=yy2;

};

int getarea() //(2分) { }

return abs((x2-x1)*(y1-y2));

void main() { }

2、(10分)

#include class car;（1分） class boat{ private:

int weight; //(1分) rectangle rect1(3,7,8,5); (2分) cout<

public: };

class car{ /(1分) private:

int weight; (1分)

boat(int w):weight(w){} //(1分)

friend int totalweight(boat b1,car c1); //(2分)

public: };

int totalweight(boat b1,car c1) //(1分) { }

void main() { }

3、(10分)

#include

class vehicle // 定义汽车类 (3分) { protected:

car c1(1000); boat b1(2000);

cout<

friend int totalweight(boat b1,car c1); (1分)

int wheels; // 车轮数 float weight; // 重量 public:

vehicle(int wheels,float weight); int get_wheels(); float get_weight(); float wheel_load(); void show(); };

class car:public vehicle // 定义小车类 (3分) {

int passenger_load; // 载人数 public:

car(int wheels,float weight,int passengers=4); int get_passengers(); void show(); };

vehicle::vehicle(int wheels1,float weight1) //(1分) {

wheels=wheels1; weight=weight1; }

int vehicle::get_wheels() {

return wheels; }

float vehicle::get_weight() {

return weight; }

void vehicle::show() (1分) {

cout << \车轮:\个\ cout << \重量:\公斤\ }

car::car(int wheels, float weight, int passengers) :vehicle(wheels, weight) {

passenger_load=passengers; }

int car::get_passengers () {

return passenger_load; }

void car::show() {

cout <<\车型:小车\ vehicle::show();

cout << \载人:\人\ cout << endl; }

void main () {

car car1(4,2000,5); (1分) cout << \输出结果\ car1. show (); (1分) }

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

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

1．参考程序： #include using namespace std; template Type Abs(Type tVar) { } int main() { }

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

class CComplex

cout << Abs(5) << endl; cout << Abs(-5) << endl; cout << Abs(2.5) << endl; cout << Abs(-2.5) << endl; return 0;

if (tVar >= 0) return tVar; else return -tVar;

{ public:

CComplex(double dReal, double dImage = 0) { }

m_dReal = dReal; m_dImage = dImage;

void Show()

{ }

CComplex operator+(const CComplex &obj) { }

CComplex objTemp(m_dReal + obj.m_dReal, m_dImage + obj.m_dImage); return objTemp; cout << m_dReal; if (m_dImage > 0) { }

else if(m_dImage < 0) { }

cout << \cout << \

private: }; int main() { }

obj3 = obj1 + obj2; obj3.Show(); return 0;

CComplex obj1(2, 6), obj2(3, 8), obj3(0);

obj1.Show(); obj2.Show(); obj3.Show();

double m_dReal, m_dImage;

1、编写程序求1至100间所有素数之和，其中求素数要求用函数实现； 2、编程打印如下图形： 1

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

参考答案：

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) { }

2、#include void main() {

for (int i=1;i<=5;i++) { for (int j=1;j<=i;j++) for(int j=2;j=x) return x; else return 0;

cout<

#include using namespace std;

// 预处理命令

// 使用标准命名空间std

const double PI = 3.1415926; class Shape {public: };

Shape() { }

// 定义常量PI

// 构造函数

virtual ~Shape() { } virtual Show() = 0; static double totalArea;

// 析构函数 // 显示面积

// 总面积

static void ShowTotalArea() { cout << \总面积:\

class Circle: public Shape {private:

double radius;

// 半径

public: };

class Rectangle: public Shape {private:

double length; double width;

// 宽

// 长

Circle(double r): radius(r) { totalArea += PI * r * r; } ~Circle() { }

// 析构函数

// 显示面积

// 构造函数

virtual Show() { cout << \圆面积:\

public: };

double Shape::totalArea = 0; int main(void) { }

// 定义圆对象 // 显示面积

// 初始化totalArea

Rectangle(double l, double w): length(l), width(w){ totalArea += l * w; } ~Rectangle() { }

// 析构函数

// 显示面积 // 构造函数

virtual Show() { cout << \矩形面积:\

Circle c(1); c.Show();

Rectangle r(1, 2); r.Show();

// 定义矩形对象

// 显示面积

Shape::ShowTotalArea(); // 显示总面积

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

return 0;

1．设计一个类DateInfo，要求其满足下述要求：

（1）要求有一个无参的构造函数，其初始的年、月、日分别为：2010，6，8。 （2）要求有一个带参数的构造函数，其参数分别对应年、月、日。 （3）要求用一个成员函数实现日期的设置。 （4）要求用一个成员函数实现输出日期。 要求用一个成员函数实现日期的获取。

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

1．参考程序： #include using namespace std; class DateInfo { private: public:

int year, month, day;

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() { }

2．参考程序： #include using namespace std; class Complex { private:

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

double r, i;

public: }; 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;

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); }

1．设计一个类Rect，要求如下：

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

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

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

class Rect { private: public: }; int main() { }

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

double x, y; try { } { } return 0;

// 检查异常

double length, width;

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); }

Rect obj(1, 8);

cout << \周长:\catch (char *str) // 处理异常

cout << \异常信息:\

// 输出异常信息

// 捕捉异常

public: };

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;

Vector2d(double a, double b): x(a), y(b) {} void Show() { cout << x << \ \Vector2d operator+(Vector2d &obj);

1、（10分）已知复数类Complex的声明如下： class Complex {public:

Complex(); //无参构造函数 Complex(double); //转换构造函数

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

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

3 4 3

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

1．若有以下程序: #include class A { int a; public: A(int aa = 0 ){ a = aa; } ~A( ) {cout << \ };

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

int main()

{ B x(5), y(6,7); return 0;

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

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

int main()

{ Point *p = new Point; p->SetPoint(5, 12); p->DisPoint(); delete p; return 0;

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

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

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

{ Sample a(2), b(5), c(8); a.Add( ); b.Add( ); 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;

}上面程序的输出结果为： 参考答案：

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

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;

本文来源：https://www.bwwdw.com/article/po1d.html