2018-2019期末复习资料答案参考cpp

最新推荐文章于 2024-04-17 15:15:14 发布

@ ^ @

最新推荐文章于 2024-04-17 15:15:14 发布

阅读量5.1k

点赞数 3

分类专栏：其他

本文链接：https://blog.csdn.net/jdbfvhxx/article/details/93392276

版权

其他专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、选择题

1．下面对于类的描述，是正确的是（ B ）
A．类是抽象数据类型的实现
B．类是具有共同行为和属性的若干对象的统一描述体
C．所有的类都能创建对象
D．类就是C语言中的结构类型

2．下列关于C++函数的说明中，正确的是 ( C )
A．内联函数就是定义在另一个函数体内部的函数
B．函数体的最后一条语句必须是return语句
C．标准C++要求在调用一个函数之前，必须先声明其原型
D．编译器会根据函数的返回值类型和参数表来区分函数的不同重载形式

3．下列不是描述类的成员函数的是( C )
A．构造函数 B．析构函数
C．友元函数 D．拷贝构造函数

4．构造函数不具备的特征的是( D )
A．构造函数的函数名与类名相同 B．构造函数可以重载
C．构造函数可以设置默认参数 D．构造函数必须指定类型说明

5．下面有关重载函数的说法中正确的是（ C ）
A．重载函数必须具有不同的返回值类型
B．重载函数形参个数必须不同
C．重载函数必须有不同的形参列表
D．重载函数名可以不同

6．下面关于C++中类的继承与派生的说法错误的是（ C ）
A．基类的protected成员在公有派生类的成员函数中可以直接使用
B．基类的protected成员在私有派生类的成员函数中可以直接使用
C．有派生时，基类的所有成员访问权限在派生类中保持不变
D．继承可以分为单一继承与多重继承

7．下面关于运算符重载的描述错误的是（ C ）
A．运算符重载不能改变操作数的个数、运算符的优先级、运算符的结合性和运算符的语法结构
B．不是所有的运算符都可以进行重载
C．运算符函数的调用必须使用关键字operator
D．在C++语言中不可通过运算符重载创造出新的运算符

8．关于虚函数的描述中，（ C ）是正确的。
A．虚函数是一个static类型的成员函数
B．虚函数是一个非成员函数
C．基类中说明了虚函数后，派生类中将其对应的函数可不必说明为虚函数
D．派生类的虚函数与基类的虚函数具有不同的参数个数和类型

9．假定AB为一个类，则执行AB x；语句时将自动调用该类的( B )
A．有参构造函数 B．无参构造函数
C．拷贝构造函数 D．赋值构造函数

10．下面关于编写异常处理代码规则中不正确的是( B )
A. 可以有数量不限的catch处理程序出现在try块之后，在try 块出现之前不能出现catch块。
B. try块中必须包含throw语句。
C. 在关键字catch之后的圆括号内的数据声明必须包括其类型声明。
D．如果catch中处理程序执行完毕，而无返回或终止指令将跳过后面的catch块继续执行

11．关于类和对象，下列说法不正确的是( C )
A.对象是类的一个实例
B.任何一个对象必定属于一个特定的类
C.一个类只能有一个对象
D.类与对象的关系类似于数据类型与变量的关系

下列叙述中，不正确的是( B )
A.类的构造函数可以重载 B.类的析构函数可以重载
C.一个类可以不定义构造函数 D.一个类可以不定义析构函数

13.关于静态数据成员，下列描述正确的是( A )
A. 在对象创建之前就存在了静态数据成员
B. 静态数据成员只能被静态成员函数访问
C. 不能再构造函数中对静态数据成员赋值
D. 对静态数据成员的访问不受访问权限的限制

14.下列对派生类的描述中，( D )是错误的。
A. 一个派生类可以做另一个派生类的基类
B. 派生类至少有一个基类
C. 派生类的成员除了它自己的成员外，还包括了它的基类的成员
D. 派生类中继承的基类成员的访问权限到派生类保持不变

15．关于虚函数的描述中，（ A ）是正确的。
A．.基类中说明了虚函数后，派生类中将其对应的函数可不必说明为虚函数
B．虚函数是一个static类型的成员函数
C．虚函数是一个非成员函数
D．派生类的虚函数与基类的虚函数具有不同的参数个数和类型

16.下列叙述，不正确的是( B )
A. 纯虚函数是一个特殊的虚函数，它没有具体的实现。
B. 一个基类中说明有纯虚函数，该基类的派生类一定不再是抽象类
C. 抽象类是指具有纯虚函数的类
D. 抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出

17.关于函数模板，描述错误的是 ( D )
A．函数模板必须由程序员实例化为可执行的函数模板
B．函数模板的实例化由编译器实现。
C．一个类定义中，只要有一个函数模板，则这个类既可以是类模板，也可以是普通类
D. 类模板的成员函数都是函数模板，类模板实例化后，成员函数也随之实例化

18．在C++中，数据封装要解决的问题是 ( D )
A．数据的规范化
B．便于数据转换
C．避免数据丢失
D．防止不同模块之间数据的非法访问

20．假定MyClass为一个类，则执行MyClass a[3],*p[2];语句时，自动调用该类构造函数 ( B )次。
A．2 B．3 C．4 D．5

21．对于下面的类MyClass，在函数f()中将MyClass对象的数据成员n的值修改为50的语句应该是( C )
class MyClass
{
public:
MyClass(int x) {n = x;}
void SetNum(int n) {this->n = n;}
private:
int n;
}
int f( )
{
MyClass *ptr = new MyClass(45);

}
A．MyClass(50); B．SetNum(50);
C．ptr->SetNum(50) ; D．ptr->n = 50;

22．友员运算符_left>_right被C++编译器解释为( A )
A．operator >(_left, _right) B． >(_left, _right)
C．_right.operator >(_left) D．_left.operator >( _right)

23．派生类的构造函数的成员初始化列表中，不能包含( C )
A．基类的构造函数
B．派生类中子对象的初始化
C．基类中子对象的初始化
D．派生类中一般数据成员的初始化

24．下面关于C++中类的继承与派生的说法错误的是( C )
A．基类的protected成员在公有派生类的成员函数中可以直接使用
B．基类的protected成员在私有派生类的成员函数中可以直接使用
C．私有派生时，基类的所有成员访问权限在派生类中保持不变
D．继承可以分为单一继承与多重继承

25．下列关于虚基类的描述中，错误的是( B )
A．虚基类子对象的初始化由最终的派生类完成
B．虚基类子对象的初始化次数与虚基类下面的派生类个数有关
C．设置虚基类的目的是消除二义性
D．带有虚基类的多层派生类构造函数的成员初始化列表中都要列出对虚基类构造函数的调用

26．关于虚函数的描述中正确的是( D )
A．虚函数是一个static类型的成员函数
B．虚函数是一个非成员函数
C．虚函数既可以在函数说明时定义，也可以在函数实现时定义
D．派生类的虚函数与基类的虚函数具有相同的参数个数和类型

27．关于纯虚函数和抽象类的描述中错误的是( C )
A．纯虚函数是一种特殊的虚函数，它没有具体的实现
B．抽象类是指具有纯虚函数的类
C．一个基类中说明有纯虚函数，该基类的派生类一定不再是抽象类
D．抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出

28．下列对模板的声明，正确的是( C )
A. template
B. template<typename T1,T2>
C. template<typename T1,class T2>
D．template<typename T1;typename T2>

已定义了一个类A并有语句A* pa=new A(5); 那么以下说法正确的是：( A )
A. 该语句会创建A类的一个对象,并将此对象的地址赋给指针pa;
B. 该语句会创建A类的5个对象,且它们的地址是连续的;
C. 当指针变量pa超出其作用域时，pa和为对象分配的空间都将被自动释放；
D. 类A中一定有一个显式定义的构造函数和一个显式定义的虚析构函数；
定义类A的非静态成员函数A& f(A& one)时，需有语句return exp;则exp不能是：( B )
A.类A中类型为A的静态数据成员
B. f中用语句A a = one; 定义的量a
C. one
D. *this
在一个类中，下列哪些成员可以是多个？ ( D )
A. 无参构造函数
B. 析构函数
C. 原型相同的非静态成员函数
D. 静态成员函数
对类T中的下列成员，若不考虑代码优化，一般来说它们中的哪个执行起来最慢？( C )
A. 缺省的无参构造函数
B. 缺省的拷贝构造函数
C. T f( ) { T t; return t; }
D. 不能判定A、B、C哪个最慢
对函数原型为int& min(int& a, int& b);的全局函数，下列语句块哪个是错误的：( C )
A. int x=10,y=5; min(x,y)=100;
B. int x=10,y=5, z; z=min(x,y+=x);
C. int x=10,y=5; min(x,10)=y;
D. int x=10,y=5; x=min(x,y);
关于拷贝构造函数错误的说法有：( B )
A. 拷贝构造函数是一种特殊的构造函数，且不能在类中进行函数重载。
B. 若自定义派生类的拷贝构造函数，那么也必须自定义基类的拷贝构造函数。
C. 通常拷贝构造函数只能有一个参数，且为常量引用或非常量引用。
D. 拷贝构造函数不允许在函数体中使用return语句。
下列对虚基类声明正确的是 ( B )
A. class virtual B: public A
B. class B: virtual public A
C. class B: public Avirtual
D. virtual class B: public A
若有语句A*const p=new B;，其中类B是从类A直接派生得到的，那么下列说法错误的是D
A. 若要执行语句p->f( );,那么类A中一定有一个与f( )函数匹配的函数声明。
B. 类B一定是通过public继承方式从类A派生的。
C. 类B的构造函数中，至少有一个无参的或提供全部缺省参数的构造函数。
D. 通过指针p，只能访问类中的常量成员函数或静态成员函数。
下面说明的哪个数据不能作为类T的数据成员定义( D )
A. T* pT
B. class Q{ } q1,q2;
C. static T t;
D. const T t;
下列哪种运算符可以被重载：(Ｄ)
A. sizeof B. ：： C. ? : D. [ ]

二、程序改错题，指出程序中的错误语句并分析错误原因

指出下面程序段中的错误，并说明出错原因

class X{
private:
	int a=0;                    //A行
	int &b;                    //B行
	const int c;                 //C行
	void setA(int i){a=i;}        //D行
	X(int i){a=i;}              //E行
public:
	int X():b(a),c(a){a =0;}                //F行
	X(int i,int j,int k):b(j),c(k){a=i; }     //G行
	static void setB(int k){b=k;}        //H行
	setC(int k)const {c=c+k;}          //I行
};
void main()
{
	X x1;                //J行
	X x2(3);             //K行
	X x3(1,2,3);          //L行
	x1.setA(3);           //M行
}
class X {
private:
	int a = 0;                    //A行
	int &b;                    //B行
	const int c;                 //C行
public:
	void setA(int i) { a = i; }        //D行
//私有成员函数类外无法访问，需定义为公有
	X(int i):b(a), c(a) { a = i; }              //E行
//构造函数需定义为公有成员且要求初始化数据成员
public:
	// int X() :b(a), c(a) { a = 0; }                //F行
	X() :b(a), c(a) { a = 0; }
	X(int i, int j, int k) :b(j), c(k) { a = i; }     //G行
//	static void setB(int k) { b = k; }        //H行
	//静态成员函数只能访问静态数据成员
	//setC(int k)const { c = c + k; }          //I行
	//c为private 且为const修饰
};
void main()
{
	X x1;                //J行
	X x2(3);             //K行
	X x3(1, 2, 3);          //L行
	x1.setA(3);           //M行
}

2.指出下面程序段中的错误，并说明出错原因

#include<iostream>
using namespace std;
class Base1 {
	int b1;                                              //A行
public: 
	Base1(int b1=0) {this->b1=b1;}                         //B行
	void f(){ cout<<"From  Base1"<<endl;}                 //C行
};
class Base2 {
	int b2;                                             //D行
public: 
	Base2(int b2){this->b2=b2;}                           //E行
	void f() { cout<<"From  Base2"<<endl;}                //F行
};
class Derived: public Base1, public Base2 {                   //G行
	int d;
public:
	Derived(int d){this->d=d;}                            //H行
	void g(){ cout<<"From  Derived"<<b1<<b2<<endl; }      //I行
};
void main(){ 
    Derived dObj(10);                                   //J行
    dObj.f();                                           //K行
    dObj.Base1::f();                                     //L行
}
class Base1 {
protected:
	int b1;                                              //A行
public:
	Base1(int b1 = 0) { this->b1 = b1; }                         //B行
	void f() { cout << "From  Base1" << endl; }                 //C行
};
class Base2 {
protected:
	int b2;                                             //D行
public:
	Base2(int b2) { this->b2 = b2; }                           //E行
	void f() { cout << "From  Base2" << endl; }                //F行
};
class Derived : public Base1, public Base2 {                   //G行
	int d;
public:
	//Derived(int d) { this->d = d; }                            //H行
	//未对基类构造函数初始化
	Derived(int d) :Base1(0), Base2(0) { this->d = d; }
	void g() { cout << "From  Derived" << b1 << b2 << endl; }      //I行
	//b1 b2为基类私有数据成员
};
void main() {
	Derived dObj(10);                                   //J行
	//dObj.f();                                           //K行
	//产生二义性,需添加调用函数范围
	dObj.Base2::f();                                           //K行
	dObj.Base1::f();                                     //L行
}

3.指出下面程序段中的错误，并说明出错原因（6分）

#include<iostream.h>
class A
{    int a;
public:
     A(int x){ a=x; }       //A行
};
class B:public A            //B行
{    int a;
public:
     B(int x){ a=x; }       //C行
     void show(){cout<<a<<'\t'<<A::a<<endl; }    //D行
};
void main()
{    B b1;                  //E行
     b1.show();              //F行
}
class A
{
protected:
	int a;
public:
	A(int x) { a = x; }       //A行
};
class B :public A            //B行
{
	int a;
public:
	B() :A(0),a(0) {  }       //C行
	B(int x):A(0) { a = x; }       //C行
	void show() { cout << a << '\t' << A::a << endl; }    //D行
	//a在A中为private,不可访问
};
void main()
{
	B b1;                  //E行
	//必须对派生类B进行显式构造无参类型
	b1.show();              //F行

三、程序填空题

1．在横线处填上适当的字句，完成下面复数类的定义（4分）。

#include<iostream.h>
class Complex
{
   private:
      double real,image;
   public:
      Complex(double r=0,double i=0) {real=r;image=i;}
      friend Complex operator+(Complex &a,const Complex &b);   //复数加法运算符
      Complex operator=(Complex c);                         //复数赋值运算符
};
Complex operator+(Complex &a,const Complex &b)
{
     Complex*t=new Complex(_____);
     return *t;
}
Complex Complex::operator=(Complex c)
{
    real=c.real;
    image=c.image;
    return_____;
}

class Complex
{
public:
	double real, image;
public:
	Complex(double r = 0, double i = 0) { real = r; image = i; }
	friend Complex operator+(Complex &a, const Complex &b);   //复数加法运算符
	Complex operator=(Complex c);                         //复数赋值运算符
};
Complex operator+(Complex &a, const Complex &b)
{
	Complex *t = new Complex(a.image+b.image,a.real+b.real);
	return *t;
}
Complex Complex::operator=(Complex c)
{
	real = c.real;
	image = c.image;
	return c;
}
int main() {
	Complex a(5, 6), b(3, 7),c(0,0);
	c = a + b;
	cout << c.image << "   " << c.real << endl;
}

2．下列程序用虚函数print和运行的多态性，把从键盘输入的一个int型数值n，按八进制和十六进制输出，完善程序（8分）。

#include<iostream.h>
class OCT{
protected:    
    int n;
public:
    OCT(int x){ n=x; }
    ________{ cout<<n<<"的八进制为："<<oct<<n<<endl; }
};
class HEX:public OCT{
public:
    HEX(int x):________
    void print(){ cout<<n<<"的十六进制为："<<hex<<n<<endl; } 
};
void main()
{   int n;
    cout<<"请输入一个十进制：";
	cin>>n;
	OCT oc(n);
	HEX he(n);
	________;
	p=&oc;
	p->print();
	________;
	p->print(); 
}


class OCT {
protected:
	int n;
public:
	OCT(int x) { n = x; }
	virtual void print(){ cout << n << "的八进制为：" << oct << n << endl; }
};
class HEX :public OCT {
public:
	HEX(int x) :OCT(0) {   }
		void print() { cout << n << "的十六进制为：" << hex << n << endl; }
};
int main()
{
	int n;
	cout << "请输入一个十进制：";
	cin >> n;
	OCT oc(n);
	HEX he(n);
	OCT *p;
	p = &oc;
	p->print();
	p = &he;
	p->print();
}

3．在横线处填上适当的语句，完成下列程序

#include<iostream>
#include<cmath>
using namespace std;
class Point{
public:
	Point(double a,double b,double c){
		___________________                     
	}
	double getX(){return x;}
	double getY(){return y;}
	double getZ(){return z;}
private:
	  __________________               
protected:
	 __________________                
};
class Line:Point{
public:
	Line(double a,double b,double c,double d)__________________)__________________{
	__________________	                   
	}
	void show(){
		cout<<getX()<<endl;
		cout<<getY()<<” ”<<y<<endl;
		cout<<getZ()<<” ”<<z<<endl;
		cout<<k<<endl;
	}
private:
	double k;
};
int main()
{
	Line obj(1.2,3.4,5.6,7.8);
	obj.show();
	return 0;
}
class Point {
public:
	Point(double a, double b, double c) {
		x=a;
		y = b;
		z = c;
	}
	double getX() { return x; }
	double getY() { return y; }
	double getZ() { return z; }
private:
	double x;
protected:
	double y, z;
};
class Line :Point {
public:
	Line(double a, double b, double c, double d): Point(a, b, c), k(d)       {

	}
	void show() {
		cout << getX() << endl;
		cout << getY() << " " << y << endl;
		cout << getZ() << " " << z << endl;
		cout << k << endl;
	}
private:
	double k;
};
int main()
{
	Line obj(1.2, 3.4, 5.6, 7.8);
	obj.show();
	return 0;
}

4．本程序自定义了一个复数类Complex类和一个求最小值的函数模板min，在横线处填上适当的语句，使得该程序的运行结果为:
hello
1+2i

#include<iostream>
#include<string>
#include<complex>
using namespace std;
class Complex{
private:
	int real;
	int image;
public:
	Complex(int,int);
	bool operator<(Complex c);
	__________________	;
};
Complex::Complex(int real = 0,int image = 0){
	this->real = real;
	this->image = image;
}
bool Complex::operator <(Complex c){
	if(__________________  )
		return true;
	else return false;
}
  _______________ operator<<(__________________ ){
	__________________ ;
	return os;
}
                      
T _min(T _left, T _right)
{
	return _left < _right ? _left : _right;
}
int main()
{
	string str1 = "hello";
	string str2 = "hollow";
	cout<<_min(str1,str2)<<endl;
	Complex c1(1,2),c2(3,4);
	cout<<_min(c1,c2);
	return 0;
}
class Complex {
private:
	int real;
	int image;
public:
	Complex(int, int);
	bool operator <(Complex c);
	friend ostream& operator <<(ostream &os, const Complex& c);
};
Complex::Complex(int real = 0, int image = 0) {
	this->real = real;
	this->image = image;
}
bool Complex::operator <(Complex c) {
	if (c.image>image&&real<c.real)
		return true;
	else return false;
}

ostream& operator <<(ostream &os, const Complex& c)
{
	os << c.real << "+" << c.image << "i";
	return os;
}
template <class  T>
T _min(T _left, T _right)
{
	return _left < _right ? _left : _right;
}
int main()
{
	string str1 = "hello";
	string str2 = "hollow";
	cout << _min(str1, str2) << endl;
	Complex c1(1, 2), c2(3, 4);
	cout << _min(c1, c2);
	return 0;
}

5．在横线处填上适当的语句，利用异常处理机制合理得处理由主函数的两条调用语句导致的异常，使得：
当调用语句为cout<<Divide(2,0)<<endl;时，输出结果为：除数不能为0!
当调用语句为cout<<Divide(1,1000)<<endl;时，输出结果为：除数太大!
当调用语句为cout<<Divide(1,2)<<endl;时，输出结果为：0.5

#include <iostream>
using namespace std;
enum errs{error0,error1};
double Divide(double dividend, double divided)
{   
		if(divided == 0) __________________ ;
		else if(divided >= 1000) __________________  ;
		else__________________;
}
void main()
{
	try{
		cout<<Divide(2,0)<<endl;
 		cout<<Divide(1,1000)<<endl;
		cout<<Divide(1,2)<<endl;
	}catch(__________________){
     	switch(er)
		{	
			case error0:
				cout<<"除数不能为0!"<<endl;
				break;
            case error1:
				cout<<"除数太大!"<<endl;
				break;
    		}		
    	} 
}
enum errs { 
	error0, 
	error1 
};

double Divide(double dividend, double divided)
{
	if (divided == 0)
		throw error0;
	else if(divided >= 1000)
		throw error1;
	else
		return dividend / divided;
}
int main()
{
	try {
		cout << Divide(2, 0) << endl;
		cout << Divide(1, 1000) << endl;
		cout << Divide(1, 2) << endl;
	}
	catch (errs er) {
		switch (er)
		{
		case error0:
			cout << "除数不能为0!" << endl;
			break;
		case error1:
			cout << "除数太大!" << endl;
			break;
		}
	}
	return 0;
}

四、程序设计题

1.（10分）定义一个大学生类student，函数私有数据成员：姓名、学号、校名，并为它定义带参数的构造函数、参数带缺省值的构造函数和输出数据成员值的print()公有成员函数，另定义研究生类，它以公有继承方式派生于类student，新增加“研究方向、导师名”两个私有数据成员，并定义带参数的构造函数和输出研究生数据的print()公有成员函数。在main()函数中定义基类和派生类对象，对类进行测试。
主函数的测试程序如下：

void main()
{
	Student stu1("Li","1600141","XingJiang University");
	stu1.print();
	GraStudent gstu("Wang","1600240","XJUniversity","Computer","Zhang");
gstu.print();
}

程序运行输出结果如下：
name=Li
StuNum=1600141
universty_name=XJU

name=Wang
StuNum=1600240
universty_name=XJU
special is Compute
director is Zhang

class Student {
protected:
	string name;
	string StuNum;
	string universty_name;
public:
	Student() {}
	Student(string name, string StuNum,string universty_name):name(name), StuNum(StuNum),universty_name(universty_name){}
	void print() {
		cout << "name = " << name << endl;
		cout << "StuNum = " << StuNum << endl;
		cout << "universty_name = " << universty_name << endl;
	};
};
class GraStudent: public Student{
private:
	string special;
	string director;
public:
	GraStudent(string name, string StuNum, string universty_name, string special, string director):Student( name,  StuNum,  universty_name), special(special),director(director){}
	void print() {
		cout << "name = " << name << endl;
		cout << "StuNum = " << StuNum << endl;
		cout << "universty_name = " << universty_name << endl;
		cout << "special = " << special << endl;
		cout << "director = " << director << endl;
	};
};

定义一个圆类，数据成员有颜色、圆心坐标、半径；成员函数有构造函数（有四个参数），设置圆的各种参数，显示圆的各种参数，计算圆的面积和周长，并编写一个主函数对所定义的圆类进行测试。（12分）

class Circle {
private:
	string color;
	double point_x;
	double point_y;
	double rad;
public:
	Circle(string color, double point_x, double point_y, double rad) :color(color), point_x(point_x), point_y(point_y), rad(rad) {}
	void setcolor(string color) { this->color = color; }
	void setpoint(double point_x, double point_y) { this->point_x = point_x; this->point_y = point_y; }
	void setrad(double rad) { this->rad = rad; }
	void show() {
		cout << color << "  " << "圆心:(" << point_x << "," << point_y << ")  " << "半径:" << rad << endl;
	};
	double getS() {
		return 3.14*rad*rad ;
	}
	double getL() {
		return 2 * 3.14*rad ;
	};
};
int main()
{
	Circle Circle("red", 0, 0, 0);
	Circle.setcolor("blue");
	Circle.setpoint(4, 5);
	Circle.setrad(3);
	Circle.show();
	cout << "面积：" << Circle.getS() << endl;
	cout << "周长：" << Circle.getL ()<< endl;
}

定义一个点类（Point）、矩形类（Rectangle）和立方体类（Cube）的层次结构。Point为基类，成员有点的x坐标和y坐标；Rectangle包括长度和宽度两个新数据成员，Rectangle的位置从Point类继承。Cube类的数据成员包括长度、宽度和高度，长度和宽度从Rectangle类继承。要求各类提供支持初始化的构造函数和显示自己成员的成员函数。编写主函数，测试这个层次结构，输出立方体类的相关信息。（12分）

class Point {
protected:
   double point_x;
   double point_y;
public:
   Point(double point_x,double point_y): point_x(point_x),point_y(point_y){}
   void show() {
   	cout << "("<<point_x << "," << point_y <<")"<< endl;
   };
};
class Rectangle:public Point {
protected:
   double length;
   double width;
public:
   Rectangle(double point_x, double point_y,double length,double width) : Point( point_x,  point_y), length(length), width(width){}
   void show() {
   	cout << "(" << point_x << "," << point_y << ")" << endl;
   	cout << "length:" << length<<endl;
   	cout << "width:" << width << endl;
   }
};
class Cube : public Rectangle {
protected:
   double height;
public:
   
   Cube(double point_x, double point_y, double length, double width,double height) : Rectangle(point_x, point_y,length, width), height(height){}
   void show() {
   	cout << "(" << point_x << "," << point_y << ")" << endl;
   	cout << "length:" << length << endl;
   	cout << "width:" << width << endl;
   	cout << "height:" << height << endl;
   }
};
int main()
{
   Point point(4,5);
   point.show();
   Rectangle Rectangle(4, 5, 6, 7);
   Rectangle.show();
   Cube Cube(7, 8, 9, 10, 11);
   Cube.show();
}

4.(共20分，每问题10分) 某程序员为了灵活地对各种的给定的曲线函数f(x)画出其曲线图形，设计并部分实现了一个曲线类curve，该类的成员数据中，count代表坐标点的个数，pxs代表的数组存放这些坐标点的横坐标，pys代表的数组存放利用f(x)计算得到的这些坐标点的纵坐标。由于不同曲线的计算公式f(x)是不同的，该程序员希望曲线函数的种类可以通过继承curve类的方式任意增加，增加一个新的f(x)时不改变curve类中的内容，也不改变利用curve类进行图形绘制的算法。已部分完成的curve类定义和实现如下：

class  curve  {
public:
   void setPxs( ) {/*把获取的横坐标数据存放在pxs代表的数组中，并为count置值*/ }
   double* getPxs( ) const { return pxs;}
   int getCount( ) const { return count;}
   double* getPys( ) const ;
private:
   double* pxs;
   double* pys;
   int count
};

请按照该程序员的设计意图给出成员函数getPys的完整实现。实现过程中，可以为curve类增加其它成员。可以假设setPxs函数已经完整实现，不需要考虑曲线的绘制和显示。

class  curve {
public:
	void setPxs() {/*把获取的横坐标数据存放在pxs代表的数组中，并为count置值*/ }
	double* getPxs() const { return pxs; }
	int getCount() const { return count; }
	double* getPys() const {
		if (pys == NULL)
			pys = new double[count];
		for (int i = 0; i < count; i++) {
			pys[i] = f(pxs[i]);
		}
	}
	virtual double f(double x) {
		return 
	}
private:
	double* pxs;
	double* pys;
	int count;
};

(共10分）定义一个抽象类Stereo，包含纯虚函数Volume（用来计算体积）。然后派生出立方体Cube类、圆球体Sphere类、圆柱体Cylinder类，分别求其体积。各立体形状的相关数据通过各类的构造函数设置。total( )则是一个通用的用以求不同立体形状的体积总和的全局函数。(圆球体的体积公式为 V=4/3PIRRR)。
1）请根据下面主函数代码，给出各个类的定义和实现。
2）请根据下面主函数代码，给出total( )函数的定义和实现。

void main( ) {
   Stereo* s[3];
s[0]=new Cube(5.0,5.0,8.0);	//实参为立方体的长、宽、高
s[1]=new Sphere(6.0);			//实参为圆球体的半径
s[2]=new Cylinder(5.0,8.0);		//实参为圆柱体的底面半径、高
   float sum=total(s,3);
   cout<<sum<<endl;
   for(int i=0;i<3;i++)  delete s[i];
 }
class Stereo {
protected:

public:
	virtual double Volume() = 0;
};
class Cube :public Stereo {
private:
	double lenth;
	double width;
	double height;
public:
	Cube(double lenth,double width,double height):Stereo(),lenth(lenth),width(width), height(height){}
	double Volume() {
		cout << lenth * width*height << endl;
		return lenth * width*height;
	}
};
class Sphere :public Stereo {
private:
	double R;
public:
	Sphere(double R) :Stereo(), R(R){}
	double Volume() {
		cout << R * R*R*(4 / 3) << endl;
		return R*R*R*(4/3);
	}
};
class Cylinder :public Stereo {
private:
	double r;
	double height;
public:
	Cylinder(double r, double height) :Stereo(), r(r),height(height) {}
	double Volume() {
		cout << 3.14*r*r*height << endl;
		return 3.14*r*r*height;
	}
};
double total(Stereo **s  ,int n) {
	double sum = 0;
	for (int i = 0; i < n; i++) {
		sum += s [i]->Volume();
	}
	return sum;
}
void main() {
	Stereo* s[3];
	s[0] = new Cube(5.0, 5.0, 8.0);	//实参为立方体的长、宽、高
	s[1] = new Sphere(6.0);			//实参为圆球体的半径
	s[2] = new Cylinder(5.0, 8.0);		//实参为圆柱体的底面半径、高
	float sum = total(s, 3);
	cout << sum << endl;
	for (int i = 0; i < 3; i++)  delete s[i];
}

@ ^ @

关注

3
点赞
踩
32

收藏

觉得还不错? 一键收藏
2
评论
2018-2019期末复习资料答案参考cpp

一、选择题1．下面对于类的描述，是正确的是（ B ）A．类是抽象数据类型的实现B．类是具有共同行为和属性的若干对象的统一描述体C．所有的类都能创建对象D．类就是C语言中的结构类型2．下列关于C++函数的说明中，正确的是 ( C )A．内联函数就是定义在另一个函数体内部的函数B．函数体的最后一条语句必须是return语句C．标准C++要求在调用一个函数之前，必须先声明其原型D．...
复制链接

扫一扫