面向对象程序设计期末综合练习三(程序填充)资料

1. 斐波那契数列的第1和第2个数分别为0和1 ，从第三个数开始，每个数等于其前两个数之和。求斐波那契数列中的前20个数，要求每行输出5个数。

#include void main() {

int f,f1,f2,i;

cout<<” 斐波那契数列：\\n”; f1=0; f2=1;

cout<cout<if(_____(2)______) cout<f2=____(3)_______;

}

cout<(1) (2) (3)

10i 2. 计算(1)i1xi1i!的值。 #include void main() {

double x,p1=1,p2=1,s=0; int i,j=1;

cout<<\"输入x的值:\"; cin>>x;

for(i=1;i<=10;i++) { p1*=___(1)_____; p2*=____(2)____;

s+=j*p1/p2; //j的值为(-1)i+1

j=____(3)____; }

cout<1

(1) (2) (3)

3. 打印出2至99之间的所有素数(即不能被任何数整除的数)。 #include #include void main() {

int i,n;

for(n=2; ___(1)___; n++) {

int temp=int(sqrt(n)); //求出n的平方根并取整 for(i=2; ___(2)___; i++) if(n%i==0) ___(3)___; if(i>temp) cout<cout<<'\\n'; }

(1) (2) (3)

4. 采用辗转相除法求出两个整数的最大公约数。 #include void main() {

int a,b;

cout<<\"请输入两个正整数:\"; cin>>a>>b;

while(a<=0 || __(1)___) {cout<<\"重新输入:\"; cin>>a>>b;} while(b) { int r; r=a%b;

___(2)___; ___(3)___; //分别修改a和b的值 }

cout<(1) (2) (3)

5. 把从键盘上输入的一个大于等于3的整数分解为质因子的乘积。如输入24时得到的输出结果为“2 2 2 3”，输入50时得到的输出结果为“2 5 5”，输入37时得到的输出结果为“37”。 #include void main() {

2

int x;

cout<<\"请输入一个整数，若小于3则重输:\"; do cin>>x; while(___(1)___); int i=2; do{

while(___(2)___) { cout<___(3)___; }while(iif(x!=1) cout<(1) (2) (3)

6. 下面函数是求两个整型参数a和b的最小公倍数。 int f2(int a, int b) {

int i=2, p=1; do {

while(a%i==0 && ___(1)___) { p*=i; a/=i; b/=i; }

___(2)___;

}while(a>=i && ___(3)___); return p*a*b; }

(1) (2) (3)

7. 在输出屏幕上打印出一个由字符’*’组成的等腰三角形，该三角形的高为5行，从上到下每行的字符数依次为1,3,5,7,9。 #include void main() {

int i,j;

for(i=1;___(1)___;i++) { for(j=1;j<=9;j++)

if(j<=5-i || ___(2)___) cout<<’ ’; else ___(3)___;

3

cout<(1) (2) (3)

8. 统计字符串中英文字母个数的程序。 #include int count (char str[]); void main(){ char s1[80];

cout <<”Enter a line:”; cin >>s1;

cout <<”count=”<int count(char str[]){

int num=0; //给统计变量赋初值 for(int i=0;str[i];i++)

if (str[i]>=’a’ && str[i]<=’z’ ||___(1)___ ) ___(2)___; ___(3)___; }

(1) (2) (3)

9. 主函数调用一个fun函数将字符串逆序。

#include #include

___(1)___; void main( ) { char s[80]; cin>>s; ___(2)___;

cout<<”逆序后的字符串:”<void fun(char ss[]) { int n=strlen(ss);

for(int i=0; ___(3)____; i++) { char c=ss[i]; ss[i]=ss[n–1–i]; ss[n–1–i]=c; }

4

}

(1) (2) (3)

10. 从一个字符串中删除所有同一个给定字符后得到一个新字符串并输出。 #include const int len=20;

void delstr(char a[],char b[],char c); void main() {

char str1[len],str2[len]; char ch;

cout<<\"输入一个字符串:\"; cin>>str1;

cout<<\"输入一个待删除的字符:\"; cin>>ch;

delstr(str1,str2,ch); cout<void delstr(char a[],char b[],char c) {

int j=0;

for(int i=0; ___(1)___; i++) if(___(2)___) b[j++]=a[i]; b[j]=___(2)___; }

(1) (2) (3)

11. 采用指针访问方式从键盘给数组a[N]输入数据，然后对元素值重新按逆序存放并输出。 #include const int N=8; void main() {

int a[N],*p,*q;

for(p=a; pint r=*p; *p=*q; *q=r; ___(2)___; ___(3)___; }

for(p=a;p5

cout<(1) (2) (3)

12. 从键盘上输入一个正整数，然后把它转换成的二进制数的每一位存放到一维数组中，最后输出该二进制数。注意二进制数的存放是按照从低位到高位的次序进行的。 #include void main() {

int x;

cout<<\"输入一个整数:\"; cin>>x;

int a[20],k=0,r; do {

r=x%2; a[k++]=r; x=___(1)___; } while(___(2)___);

for(--k;k>=0;k--) ___(3)___; cout<(1) (2) (3)

13. 对数组a[n]按升序进行的选择排序算法 void SelectSort(int a[], ___(1)___) {

int i,j,k;

for(i=1;ifor(j=i;jif(a[j]int x=a[i-1]; a[i-1]=a[k]; ___(3)___; } }

(1) (2) (3)

14. 对数组a[n]按升序进行的插入排序算法 void InsertSort(___(1)___, int n) {

6

int i,j,x;

for(i=1;ifor(j=i-1;j>=0;j--) //为x顺序向前寻找合适的插入位置 if(x(1) (2) (3)

15. 对按从小到大排列的有序数组a[n]进行二分查找x的算法，若查找成功返回该元素下标，否则返回-1。

int BinarySearch(int a[],int x) {

int low=0, high=N-1; //定义并初始化区间下界和上界变量 int mid; //定义保存中点元素下标的变量 while(low<=high) { mid=___(1)___;

if(x==a[mid]) ___(2)___;

else if(xreturn -1; }

(1) (2) (3)

16. 用插入排序方法对table指针数组中size个指针所指向的字符串进行按升序排序的算法。 void sort(char *table[], int size){ for(int i=1,___(1)___; i++){ char *p=table[i];

for(int j=i-1; j>=0 ; j--)

if(strcmp(p,table[j])<0) ___(2)___; else break;

table[j+1]=___(3)___; } }

(1) (2) (3)

7

17. 假定有定义为“struct NODE{int data; NODE* next;};”，下面算法根据table数组中的n个元素建立一个表头指针为L的链表，链表中结点值的顺序与数组元素值的顺序相同。 void f5(NODE*& L, int table[], int n) {

if(n<=0) {L=NULL; return;}

L=new NODE; //生成附加的头结点 int i=0; NODE* p=L;

while(__ip=p->next=__new NODE__; p->data=__table[i]___; i++; }

p->next=NULL; //把最后一个结点的指针域置空 p=L;

L=L->next; //使L指向链表的第一个带值的结点 delete p; }

(1) (2) (3)

18. 假定有定义为“struct NODE{int data; NODE* next;};”，下面算法根据table数组中的n个元素建立一个表头指针为L的链表，链表中结点值的顺序与数组元素值的顺序正好相反。 void f6(NODE*& L, int table[], int n) {

L=NULL;

if(n<=0) return; int i=0; NODE* p;

while(__ip->data=__table[i]__; p->next=L; __L=p__; i++; } }

(1) (2) (3)

19. 假定有定义为“struct NODE{int data; NODE* next;};”，下面算法是依次显示输出以L为表头指针的链表中各结点的值。

8

void f7(NODE* L) {

for(___(1)___; p!=NULL; ___(2)___) cout<<___(3)___ <<' '; cout<(1) (2) (3)

20. 假定有定义为“struct NODE{int data; NODE* next;};”，下面算法是把以L为表头指针的链表中各结点依次按相反次序链接并返回新链表的表头指针。 NODE* f8(NODE* L) {

if(L==NULL) return NULL; NODE *p=NULL, *q=L, *t; while(q!=NULL) { t=q;

q=___(1)___;

t->next=___(2)___; p=t; }

___(3)___; }

(1) (2) (3)

21. 已知一维数组类ARRAY的定义如下，ARRAY与普通一维数组区别是：其重载的运算符[ ]要对下标是否越界进行检查。 class ARRAY{

int *v; //指向存放数组数据的空间 int s; //数组大小 public:

ARRAY(int a[], int n); ~ ARRAY(){delete []v;} int size(){ return s;} int& operator[](int n); };

___(1)___ operator[](int n) //[ ]的运算符成员函数定义 {

if(n<0 || ___(2)___) {cerr<<\"下标越界！\"; exit(1);} return ___(3)___; }

9

(1) (2) (3)

22. 已知一维数组类ARRAY的定义如下，构造函数的作用是把参数n的值赋给s，给v动态分配长度为n的数组空间，接着利用数组参数a初始化v所指向的数组。 class ARRAY{

int *v; //指向存放数组数据的空间 int s; //数组大小 public:

ARRAY(int a[], int n); ~ ARRAY(){delete []v;} int size(){ return s;} int& operator[](int n); };

___(1)___ ARRAY(int a[], int n) {

if(n<=0) {v=NULL;s=0;return;} s=n;

v=___(2)___;

for(int i=0; i(1) (2) (3)

23. 下面是一维数组类ARRAY的定义，ARRAY与普通一维数组区别是：(a)用()而不是[]进行下标访问，(2)下标从1而不是从0开始，(c)要对下标是否越界进行检查。 class ARRAY{

int *v; //指向存放数组数据的空间 int s; //数组大小 public:

ARRAY(int a[], int n); ~ ARRAY(){delete []v;} int size(){ return s;} int& operator()(int n);

}; int& ARRAY:: operator()(int n) { // ()的运算符函数定义

if(n<1 || n>s) {cerr<<\"下标越界！\"; exit(1);} return v[n-1]; }

(1) (2) (3)

10

24. 已知一个类的定义如下： #include class AA { int a[10]; int n; public:

void SetA(int aa[], int nn); //用数组aa初始化数据成员a， //用nn初始化数据成员n int MaxA(); //从数组a中前n个元素中查找最大值

void SortA(); //采用选择排序的方法对数组a中前n个元素 //进行从小到大排序

void InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序 void PrintA(); //依次输出数组a中的前n个元素 };

该类中MaxA()函数的实现如下，请在标号位置补充适当的内容。 int AA::MaxA() {

int x=a[0];

for(int i=1; ix) x=a[i]; return x; }

(1) (2) (3)

25. 已知一个类的定义如下： #include class AA { int a[10]; int n; public:

void SetA(int aa[], int nn); //用数组aa初始化数据成员a， //用nn初始化数据成员n int MaxA(); //从数组a中前n个元素中查找最大值

void SortA(); //采用选择排序的方法对数组a中前n个元素 //进行从小到大排序

void InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序 void PrintA(); //依次输出数组a中的前n个元素 };

void AA::SortA()

11

{

int i,j;

for(i=0; iif(a[j](1) (2) (3)

26. 已知一个类的定义如下： #include class AA { int a[10]; int n; public:

void SetA(int aa[], int nn); //用数组aa初始化数据成员a， //用nn初始化数据成员n int MaxA(); //从数组a中前n个元素中查找最大值

void SortA(); //采用选择排序的方法对数组a中前n个元素 //进行从小到大排序

void InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序 void PrintA(); //依次输出数组a中的前n个元素 };

void AA::InsertA() {

int i,j;

for(i=1; ifor(j=i-1; j>=0; j--)

if(x(1) (2) (3)

12

27. 已知一个类的定义如下： #include class AA { int a[10]; int n; public:

void SetA(int aa[], int nn); //用数组aa初始化数据成员a， //用nn初始化数据成员n int MaxA(); //从数组a中前n个元素中查找最大值

void SortA(); //采用选择排序的方法对数组a中前n个元素 //进行从小到大排序

void InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序 void PrintA(); //依次输出数组a中的前n个元素 //最后输出一个换行 };

使用该类的主函数如下： void main() {

int a[10]={23,78,46,55,62,76,90,25,38,42}; AA x;

x.SetA(a,6); int m= x.MaxA(); x.PrintA(); cout<该程序运行结果为:

23 78 46 55 62 76// x.PrintA()只输出6个数，所以（1）只能是x.SetA(a,6) 78

(1) (2) (3)

28. 已知一个类的定义如下： #include class AA { int a[10]; int n; public:

void SetA(int aa[], int nn); //用数组aa初始化数据成员a， //用nn初始化数据成员n int MaxA(); //从数组a中前n个元素中查找最大值

void SortA(); //采用选择排序的方法对数组a中前n个元素

13

//进行从小到大排序

void PrintA(); //依次输出数组a中的前n个元素， //最后输出一个换行 };

使用该类的主函数如下： void main() {

int a[10]={23,78,46,55,62,76,90,25,38,42}; ___(1)___; x.SetA(a,8); int ___(2)___; ___(3)___; x.PrintA(); cout<该程序运行结果为: 23 25 46 55 62 76 78 90 90

(1) (2) (3)

29. 已知一个利用数组实现栈的类定义如下： const int ARRAY_SIZE=10; class Stack { public:

void Init() {top=-1;} //初始化栈为空

void Push(int newElem); //向栈中压入一个元素 int Pop(); //从栈顶弹出一个元素 bool Empty() { //判栈空

if(top==-1) return true;else return false;} int Depth() {return top+1;} //返回栈的深度 void Print();

//按照后进先出原则依次输出栈中每个元素，直到栈空为止 private:

int elem[ARRAY_SIZE]; //用于保存栈元素的数组 int top; //指明栈顶元素位置的指针 };

void Stack::Push(int newElem) { if(___(1)___) {

14

cout<<\"栈满!\"<___(2)___;

elem[top]=___(3)___; }

(1) (2) (3)

30. 已知一个利用数组实现栈的类定义如下： const int ARRAY_SIZE=10; class Stack { public:

void Init() {top=-1;} //初始化栈为空

void Push(int newElem); //向栈中压入一个元素 int Pop(); //从栈顶弹出一个元素 bool Empty() { //判栈空

if(top==-1) return true;else return false;} int Depth() {return top+1;} //返回栈的深度 void Print();

//按照后进先出原则依次输出栈中每个元素，直到栈空为止 private:

int elem[ARRAY_SIZE]; //用于保存堆栈元素的数组 int top; //指明栈顶元素位置的指针 };

该类的Pop和Print函数的实现分别如下： ___(1)___ {

if(top==-1) {

cout<<\"栈空!\"<return ___(2)___; }

void Stack::Print() { while(!Empty())

cout<<___(3)___ <<' '; }

(1) (2) (3)

15

31．class A { int a; public:

A() {a=0;}

___(1)___{} //定义构造函数，用参数aa初始化数据成员a };

main() {

___(2)___; //定义类A的指针对象p

___(3)__; //用p指向动态对象并初始化为整数5 }

(1) (2) (3)

32．class A { char *a; public:

___(1)___ //定义无参构造函数，使a的值为空 A(char *aa) { a=___(2)___;

strcpy(a,aa); //用aa所指字符串初始化a所指向的动态存储空间 }

___(3)___ //定义析构函数，删除a所指向的动态存储空间 };

(1) (2) (3)

33．class A { int a,b; public:

A(int aa=0, int bb=0) ___(1)___ {} //分别用aa和bb对应初始化a和b };

main() {

___(2)___ ; //定义类A的对象x并用5初始化，同时定义y并用x初始化 ___(3)___ ; //定义p指针，使之指向对象x }

(1) (2) (3)

34．class A { int a,b; public:

___(1)___ //定义构造函数，使参数aa和bb的默认值为0，

16

//在函数体中用aa初始化a，用bb初始化b };

main() {

A *p1, *p2;

___(2)___ ; //调用无参构造函数生成由p1指向的动态对象 ___(3)___ ; //调用带参构造函数生成由p2指向的动态对象， //使a和b成员分别被初始化为4和5 }

(1) (2) (3)

35. #include #include class A {

int *a; int n; int MaxLen; public:

A(): a(0), n(0), MaxLen(0) {} A(int *aa, int nn, int MM) { n=nn;

MaxLen=MM;

if(n>MaxLen) exit(1);

___(1)___; //由a指向长度为MaxLen的动态数组 for(int i=0; i~A() {delete []a;}

int GetValue(int i) ___(2)___ //函数体返回a[i]的值 };

void main() {

int b[10]={1,2,3,4,5,6,7,8,9,10}; A r(b,10,10); int i,s=0;

for(i=0; i<10; i++); ___(3)___ //把r对象的a数据成员中的每个 //元素值依次累加到s中 cout<<\"s=\"<(1) (2) (3)

36. #include #include class A {

17

int *a; int n; int MaxLen; public:

A(): a(0), n(0), MaxLen(0) {} A(int *aa, int nn, int MM) { n=nn;

MaxLen=MM;

if(n>MaxLen) exit(1); a=new int[MaxLen];

___(1)___; //以i为循环变量把aa数组中每个元素值 //传送给a数组的对应元素中 } ~A();

int GetValue(int i) {return a[i];} //函数体返回a[i]的值

};

___(2)___ //析构函数的类外定义

void main() {

int b[10]={1,2,3,4,5,6,7,8,9,10}; A r(b,10,10); int i,s=0;

___(3)___ ; //以i为循环变量，把r对象的a数据成员中的 //每个元素值依次累加到s中 cout<<\"s=\"<(1) (2) (3)

37. 一种类定义如下: class Goods {

private:

char gd_name[20]; //商品名称 int weight; //商品重量

static int totalweight; //同类商品总重量 public:

Goods (char*str,int w){ //构造函数 strcpy(gd_name,str); weight=w;

totalweight+=weight; }

18

~ Goods (){totalweight -= weight;}

char* GetN(){return gd_name;} //返回商品名称 int GetW(){return weight;}

static int GetTotal_Weight() { //定义静态成员函数返回总重量 return totalweight; } };

(1) (2) (3)

38. class Point {

private: int x, y; public:

Point(){x=y=0;}

Point(int x0,int y0) {x=x0;y=y0;} int GetX() { return x; } int GetY() { return y; }

void Print(){cout<<\"Point(\"<Point operator+(Point& pt,int dd)

//加号操作符重载函数，实现Point类对象与整数加法 {

Point temp=pt; temp.x+=dd; temp.y+=dd; return temp; }

Point operator+(Point& pt1,Point& pt2)

//加号操作符重载函数，实现两个Point类对象的加法 {

Point temp=pt1; temp.x+=pt2.x; ___(3)___; return temp; }

19

(1) (2) (3)

39. 在下面一段类定义中， Derived类是由直接基类Base 1和Base 2所派生的，Derived类包含有两个间接基类BaseBase，在初始化函数Init中，需要把x1和x2的值分别赋给属于基类Base1的x成员和属于基类Base2的x成员。 class BaseBase { protected: int x; public:

BaseBase(){ x = 1;} };

class Base1: public BaseBase { public: Base1(){} };

class Base2: public BaseBase { public: Base2(){} };

class Derived: ___(1)___ {

public:

Derived() {}

void Init(int x1, int x2) { ___(2)___; ___(3)___; }

void output() {cout<(1) (2) (3)

40. 在下面一段类定义中， Derived类公有继承了基类Base。需要填充的函数由注释内容给出了功能。 class Base {

private:

int mem1,mem2; //基类的数据成员

20

public:

Base(int m1,int m2) { mem1=m1; mem2=m2; }

void output(){cout<class Derived: public Base {

private:

int mem3; //派生类本身的数据成员 public:

//构造函数,由m1和m2分别初始化mem1和mem2，由m3初始化mem3 Derived(int m1,int m2, int m3); //输出mem1,mem2和mem3数据成员的值 void output(){

___(1)___; cout<Derived::Derived(int m1,int m2, int m3): ___(2)___ {___(3)___;}

(1) (2) (3)

41. 在下面一段类的定义中，需要填充的函数由注释内容给出了功能。class Point //定义坐标点类 {

public:

int x,y; //点的横坐标和纵坐标 Point(){x=0;y=0;}

Point(int x0,int y0) {x=x0; y=y0;} int X(){return x;} int Y(){return y;}

void PrintP(){cout<<\"Point:(\"<class Line: public Point //利用坐标点类定义直线类 {

private:

class Point pt1,pt2; //直线的两个端点

21

public:

Line(Point pts, Point pte); //构造函数，分别用参数初始化对应的端点 double Dx(){return pt2.x-pt1.x;} double Dy(){return pt2.y-pt1.y;} double Length(){ //计算直线的长度 return sqrt(___(1)___); };

void PrintL(); //输出直线的两个端点和直线长度 };

Line::Line(Point pts, Point pte) ___(2)___ void Line::PrintL() {

cout<<\"1st \"; pt1.PrintP(); cout<<\"2nd \"; pt2.PrintP();

cout<<\"The Length of Line: \"<<___(3)___ <(1) (2) (3)

42. 在下面一段类的定义中，自行车类的虚基类为车辆类，机动车类的虚基类也为车辆类，摩托车类的基类为自行车类和机动车类，类之间均为公有继承。 class vehicle //车辆类 {

private:

int MaxSpeed; //最大车速 int Weight; //车重 public:

vehicle(){MaxSpeed=0; Weight=0;};

virtual void Run() {cout<<\"A vehicle is running!\"<class bicycle : ___(1)___ //自行车类 {

private:

int Height; //车高 public:

bicycle(){};

void Run() {cout<<\"A bicycle is running!\"<22

class motorcar : ___(2)___ //机动车类 {

private:

int SeatNum; //乘人数 public:

motorcar(){};

void Run() {cout << \"A motorcar is running!\" << endl; } };

class motorcycle: ___(3)___ //摩托车类 {

public:

motorcycle (){};

void Run() {cout<<\"A motorcycle is running!\"<(1) (2) (3)

程序填充参考解答

1. (1) f1+f2 (2) i%5==0 (3) f 2. (1) x (2) i (3) -j 3. (1) n<=99 (2) i<=temp (3) break 4. (1) b<=0 (2) a=b (3) b=r 5. (1) x<3 (或x<=2) (2) x%i==0 (3) i++ 6. (1) b%i==0 (2) i++ (或++i) (3) b>=i

7. (1) i<=5 (2) j>=5+i (3) cout<<’*’ 8. (1) str[i]>=’A ’&& str[i]<=’Z’ (2) num++ (3) return num 9. (1) void fun(char ss[]) (2) fun(s) (3) i11. (1) cin>>*p (2) p++ (或++p) (3) q-- (或--q) 12. (1) x/2 (2) x!=0 (3) cout<14. (1) int a[] (或int* a) (2) a[j+1]=a[j] (3) break 15. (1) (low+high)/2 (2) return mid (3) low=mid+1 16. (1) inext (3) p->data 20. (1) q->next (2) p (3) return p

21. (1) int& ARRAY:: (2) n>=s (3) v[n] (或*(v+n)) 22. (1) ARRAY:: (2) new int[n] (3) v[i]=a[i]

23

23. (1) int& ARRAY:: (2) n<1 || n>s (3) v[n-1] (或*(v+n-1)) 24. (1) AA::MaxA() (2) x=a[i] (3) return x

25. (1) i27. (1) x.SetA(a,6) (2) x.MaxA() (3) x.PrintA() 28. (1) AA x (2) m=x.MaxA() (3) x.SortA()

29. (1) top==ARRAY_SIZE-1 (2) top++（或++top） (3) newElem 30. (1) int Stack::Pop() (2) elem[top--] (3) Pop()

31. 答案：(1) A(int aa):a(aa) (2) A *p (3) p=new A(5) 32. 答案：(1) A() {a=0;} 或A():a(0){} 注：数据0可用NULL代替 (2) new char[strlen(aa)+1] (3) ~A() {delete []a;} 33. 答案：(1) :a(aa),b(bb)

(2) A x(5),y(x) 注：x(5)与x=5等效，y(x) 与y=x等效 (3) A *p=&x

34. 答案：(1) A(int aa=0, int bb=0){a=aa; b=bb;} (2) p1=new A

(3) p2= new A(4,5)

35. 答案：(1) a=new int[MaxLen] (b) {return a[i];} (c) s+=r.GetValue(i)

36. 答案：(1) for(int i=0; i(3) for(i=0; i<10; i++) s+=r.GetValue(i)

37. (1) return gd_name (2) static int (3) return totalweight 38. (1) friend Point operator+(Point& pt,int dd)

(2) friend Point operator+(Point& pt1,Point& pt2) (3) temp.y+=pt2.y

39. (1) public Base1, public Base2

(2) Base1::x=x1 (3) Base2::x=x2

40. (1) Base::output() (2) Base(m1,m2) (3) mem3=m3 41. (1) Dx()*Dx()+Dy()*Dy()

(2) {pt1=pts;pt2=pte;} (或 :pt1(pts),pt2(pte){}) (3) Length()

42. (1) virtual public vehicle

(2) virtual public vehicle

(3) public bicycle, public motorcar

24