若有如下类定义：class Shape {public:virtual void Draw（)=0;};则下列关于Shape类的叙述中，正确的是（)。

A.一切成功编译

B.Shape可以编译，Square不能编译

C.Square可以编译，Shape不能编译

D.Square，Shape都不能编译

A.类Shape中的Draw函数是纯虚函数

B.类Shape是抽象类

C.类Shape是虚基类

D.Shapes;能建立Shape的对象s

/****************** 文件shape.h*************************/

const float PI=3.14159f; // 定义圆周率常量

class Shape // 几何图形抽象类

{

public:

virtual float GetPerimeter()=0; // 纯虚函数，计算周长

virtual float GetAre()=0; // 纯虚函数，计算面积

};

class Rectangle: public Shape // 矩形类

{

public:

Rectangle (float len,float wid):length(len),width(wid){}

~Rectangle (){}

float GetPerimeter() {return 2*(length width);} // 计算矩形周长

float GetAre() {return length*width;} // 计算矩形面积

private:

float length, width; // 矩形的长和宽

};

class Circle: public Shape // 圆类

{

public: // 在下面编写每个成员函数

private:

float rad; // 圆的半径

};

class Square: public Rectangle // 正方形类

{

public:

Square(float len): Rectangle(len,len){}

~Square(){}

};

若有如下类定义： class B { void fun1() { protected: double var1; public: void fun2() { }, class D: public B protected: void fun3() { };已知obj是类D的对象，下列语句中不违反类成员访问控制权限的是

A．obj.fun1()；

B．obj.varl；

C．obj.fun2()；

D．obj.fun3()；

若有如下类定义： class B{ void funl(){} protected： double varl： public： void fun2(){} }； class D：public B{ protected： void fun3(){} }； 已知obj是类D的对象，下列语句中不违反类成员访问控制权限的是()。

A．obj.funl()；

B．obj.varl；

C．obj.fun2()；

D．obj.fun3()；

若有如下类定义： class B{ void fun1(){} private： double varl； public： void fun2(){ } }； class D：public B{ private： void fun3(){ } }； 已知obj是类D的对象，下列语句中不违反类成员访问控制权限的是

A．obj．fun1()；

B．obj．varl；

C．obj．fun2()；

D．obj．fun3()；

（31 ）若有如下类定义 :

class B{

void fun1(){}

protected:

double varl;

public:

void fun2(){}

};

class D:public B{

protected:

void fun3(){}

};

已知 obj 是类 D 的对象，下列句中不违反类成员访问控制权限的是

A ） obj.funl();

B ） obj.varl;

C ） obj.fun2();

D ） obj.fun3();

有类定义如下：

class Type{

public：

Type(int i=0)；

Type operator-(int)；

friend Type operator+(Type，Type)；

private：

int val；

}；

若有对象定义Type c1；则下列语句序列中，错误的是

A．Type(3)+c1；

B．c1+Type(3)；

C．3-c1；

D．c1-3；

A.class B implements A{ void method1() { } void method2() { } }

B.class B { void method1(int i ) { } void method2(int j ) { } }

C.class B implements A { void method1(int i ) { } void method2(int j ) { } }

D.class B implements A{ public void method1(int x ) { } public void method2(int y ) { } }

A.class B implements A{ void method1() { } void method2() { } }

B.class B { void method1(int i ) { } void method2(int j ) { } }

C.class B implements A { void method1(int i ) { } void method2(int j ) { } }

D.class B implements A{ public void method1(int x ) { } public void method2(int y ) { } }