C++面向对象程序设计[习题解答]

}

float Distance::fDist(Point p1,Point p2) { }

double x,y; x=p1.X -p2.X ; y=p1.Y -p2.Y ;

return float(sqrt(x*x+y*y)); Distance d;

cout<<\; cout<

A．设置参数默认值时，应当全部设置

B．设置参数默认值后，调用函数不能再对参数赋值

C．设置参数默认值时，应当从右向左设置 D．只能在函数定义时设置参数默认值 9．74 10．13 思考题

1． 利用重载求两个整数、三个整数和四个整数的最小

值。

#include %using namespace std;

第3章 函数重载与内联函数

1．为什么要进行函数重载？ 解：当函数实现的是同一类功能，只是部分细节不同(如参数的个数或参数类型不同)时，利用函数重载机制可以将这些函数取成相同的名字，从而使程序易于阅读和理解，方便记忆和使用。 2．什么是内联函数？

解：内联函数是一个函数，它与一般函数的区别是在使用时可以像宏一样展开，所以没有函数调用的开销。因此，使用内联函数可以提高系统的执行效率。 3．函数重载的意义主要在于( A )。 A．使用方便，提高可读性 执行效率

C．减少存储空间开销 程序可靠性

4．下面关于重载函数的说法中正确的是( C )。 A．重载函数一定具有不同的返回值类型

D．提高B．提高

int Min(int x1,int x2); int Min(int x1,int x2,int x3); int Min(int x1,int x2,int x3,int x4); int main() { }

int Min(int x1,int x2) { }

int Min(int x1,int x2,int x3)

return (x1

cout<<\<>x1>>x2>>x3>>x4; cout<

{

B．重载函数形参个数一定不同

C．重载函数一定有不同的形参列表

int y;

y=x1

D．重载函数名可以不同

}

5．一个函数功能不太复杂，但要求被频繁调用，选用( A )。 A．内联函数 D．嵌套函数

B．重载函数

C．递归函数

int Min(int x1,int x2,int x3,int x4) { }

int y1,y2; y1=x1

6．将函数声明为内联函数的关键字是( C )。 A．register B．static C．inline

D．extern

B．开关语句

C．赋值语句

7．在内联函数内允许使用的是( C )。 A．循环语句

D．以上都允许

8．在C++中，下列关于参数默认值的描述中正确的是( C )。

2．利用重载计算长方形、正方形、圆、梯形的面积和体积。

#include \

5 / 15

using namespace std;

float Area(float x,float y); float Area(float x);

float Area(float r,const double pi); float Area(float a,float b,float h); float Volumn(float a,float b,float h); float Volumn(float a);

float Volumn(float r,const float pi);

float Volumn(float a,float b,float a1,float b1,float h); int main() { }

float Area(float x,float y) { }

float Area(float x) {

return x*x; return x*y; float x,y,z,x1,y1; const float PI=3.14;

cout<<\计算面积---------\<>x>>y;

cout<<\长方形的面积是:\<>x;

cout<<\正方形的面积是:\<>x;

cout<<\圆的面积是:\<>x>>y>>z;

cout<<\梯形的面积是:\<>x>>y>>z;

cout<<\长方形的体积是:\<>x;

cout<<\正方形的体积是:\<>x;

cout<<\圆的体积是:\<

cout<<\输入上底边长a、b，下底边长a1、b1，以及高\<>x>>y>>x1>>y1>>z;

cout<<\梯形的体积是:\<

}

float Area(float r,const double pi) { }

float Area(float a,float b,float h) { }

float Volumn(float a,float b,float h) { }

float Volumn(float a) { }

float Volumn(float r,const float pi) { }

float Volumn(float a,float b,float a1,float b1,float h) { }

return h*(a*b+(a+a1)*(b+b1)+a1*b1)/6.0; return 4*pi*r*r*r/3; return a*a*a; return a*b*h; return (a+b)*h/2; return pi*r*r;

3．利用重载实现对10个整数和10个实数的排序。

#include %using namespace std; void sort(int a[],int n); void sort(float a[],int n); int main() {

6 / 15

const int n=10; int i,a[n]; float b[n];

cout<<\输入\<

cin>>a[i]; sort(a,n);

cout<<\排序结果为：\<

cout<

cout<<\输入\<

cin>>b[i];

sort(b,n);

cout<<\排序结果为：\<

}

void sort(int a[],int n) { }

void sort(float a[],int n) { }

int i,j; float t;

for (i=0;i

for (j=i+1;j

if(a[i]

t=a[i]; a[i]=a[j]; a[j]=t;

int i,j,t;

for (i=0;i

for (j=i+1;j

if(a[i]

t=a[i]; a[i]=a[j]; a[j]=t;

for(i=0;i

cout<

由编译器分配给它一个编译单元。(2) 当定义一个常量(const)时，必须初始化，即赋初值给它，除非

用extern做了清楚的说明。

2．指出下面非法的定义。（D）

A．int I; B．const int ic; C．const int *pic; D．int *const cpi;

3．下列哪些初始化为合法的？指出原因。(D) A．int i=1;

B．const int ic=I; C．const

int

*pic=⁣

D．int *const cpi=⁣

E． const int *const

cpic=⁣

4．根据第3题，以下赋值哪些是非法的？为什么？(E) A．i=ic;

B．pic=cpic;

C．pic=⁣

D．cpic=⁣

E．cpi=pic; F．ic=*cpic;

5．下列定义中，哪些是无效的？为什么？如何改正？(BDFGIJ)

A．int i=1.02; B．int &j=1.002; C．int & k=i;

D．int &m=&i;

F．int &n=pi;

G．int &p=*pi;

E．int *pi=&i;

H．int &* pval=pi;

I．const int &iv=1;

J．const int &*

pval=&ival;

6．下面的类型声明中正确的是(D)。 A．int &a[4]; B．int &*p;

C．int &&q;

D．int i,*p=&i;

7．建立一个包含const成员的类，在构造函数初始化表达式里初始化这个const成员，建立一个无标记的枚举，用它决定一个数组的大小。

class conClass{ const int NUM; public:

conClass(); };

conClass::conClass():NUM(100){}

第4章 常量与引用

1．使用const的优点是什么？应该注意哪些问题？ 答：使用const的好处是它允许指定一种语意上的约束：某种对象不能被修改——而由编译器具体来实施这种约束。通过const，可以通知编译器和其他程序员某个值要保持不变。

注意问题：

(1) 尽量把const定义放进头文件里，由此通过包含头

文件，把const定义放在一个需要放置的地方，并

8．建立一个类，该类具有const和非const成员函数。建立这个类的const和非const对象，试着为不同类型的对象调用不同类型的成员函数。

class Student{ int No; char Name[20]; public: Student(); int GetNo()const; //const成员函数

const char* GetName(); //返回值为const的成员函数，不是const成员函数

};

7 / 15

int Student::GetNo()const{ return No; }

const char* Student::GetName(){ return Name; }

A．说明静态数据成员时，前边要加关键字static B．静态数据成员在类外进行初始化

C．引用静态数据成员时，要在静态数据成员名前加<类名>和作用域运算符

D．静态数据成员不是所有对象所共有的

2．下列关于静态数据成员的叙述，错误的是( A )。 A．静态数据成员在对象调用析构函数后，从内存中撤销

B．即使没有实例化类，静态数据成员也可以通过类名进行访问

C．类的静态数据成员是该类所有对象所共享 D．类的静态数据成员需要初始化

3．下列关于静态成员的叙述中，错误的是( B )。 A．类的外部可以直接调用类的静态数据成员和静态成员函数

B．与一般成员一样，只有通过对象才能访问类的静态成员

C．类的静态数据成员不能在构造函数中初始化 D．类的一般成员函数可以调用类的静态成员 4．声明类的成员为静态成员，必须在其前面加上关键字( B )。

A．const B．static D．virtual

C．public

9．引用的使用规则是什么？

答：(1) 当引用被创建时，它必须被初始化(指针则可以在任何时候被初始化)。

(2) 一旦一个引用被初始化为指向一个对象，它就不能被改变为对另一个对象的引用(指针则可以在任何时候指向另一个对象)。 (3) 没有NULL引用。必须确保引用是和一个合法的存储单元关联。

10．写一个带有拷贝构造函数的类，并编写一个测试它的程序，以观察在值传递时，拷贝构造函数是否被调用。 class Student{ static int number; public:

Student(){ number++;

show(\ }

//拷贝构造函数 Student(const Student&){ number++; show(\} };

int Student::number=0; Student f(Student x){ x.show(\ }

return x;

5．静态成员为该类的所有( B )共享。 A．成员 B．对象 C．this指针 D．友元 6．程序运行结果：

1 2 3

7．程序运行结果：CStatic::val=10

思考题

1．利用静态数据成员的概念，编写一个类，统计目前存在多少个该类的对象。

class A { private:

int main(){

Student h1;

Student h2=f(h1);

static int n;

Student::show(\return 0;

public:

A() { }

void Print() { }

cout<

} 11.略

第5章 静态与命名控制

1．下列静态数据成员的特性中，错误的是( D )。

8 / 15