C++填空题

更正后程序的输出应该是：

5!=120

[程序]

#include<iostream>

using namespace std;

class Factorial{// “阶乘”类，求n阶乘的值f

      int n;

      int f;// n!的值

public:

      //ERROR**********found**********

      void Factorial(int t=0):n(t),f(1){ }

      void fun( );  // 求n!

      int getn(){ return n;}

      int getf(){ return f;}

};

//ERROR**********found**********

void fun( )

{

      int i;

      for(i=2;i<=n;i++)

      f*=i;

}

int main()

{

      Factorial obj(5);

      obj.fun();

      //ERROR**********found**********

      cout<<obj.n<<!=<<obj.f<<endl;

      system(pause);

      return 0;

}

更正后程序的输出应该是：

     This ia a string.

[程序]

#include <iostream>

#include <cstring>

using namespace std;

class STR{//“字符串”类

    char *s;

public:

    STR(char *p)

    {

       s=new char[ strlen(p)+1 ]; //分配动态空间

       //ERROR**********found**********

       s=p;//对动态空间赋值

    }

    void print()const

    {

       cout<<s<<endl;

    }

    //ERROR**********found**********

    void ~STR()

    {

       //ERROR**********found**********

       delete s[];//释放动态空间

    }

};

int main()

{

    char t[]=”This ia a string”.;

    STR test(t); //以数组t初始化STR类的对象

    test.print();

    system(pause);

    return 0;

}

更正后程序的输出应该是：

     0

     10

[程序]

#include <iostream>;

using namespace std;

class Class_Object{

public:

      //ERROR**********found**********

       void Class_Object(int=0);

       void set(int);

       int get();

private:

       int member;

};

Class_Object::Class_Object(int m):member(m){}

void Class_Object::set(int m)

{

       //ERROR**********found**********

       m=member;

}

int Class_Object::get()

{

       return member;

}

int main()

{

       Class_Object test;

       cout<<test.get()<<endl;

      //ERROR**********found**********

       test.member=10;

       cout<<test.get()<<endl;

       system(pause);

       return 0;

}

更正后程序的输出应该是：

         fruit1是苹果吗？true

         fruit1是梨吗？false

         fruit2是苹果吗？false

         fruit2是梨吗？true

[程序]

#include<iostream>

#pragma warning(disable:4996)

using namespace std;

class Fruits{//水果类

public:

      Fruits(char *the_name,float the_price);

      //ERROR**********found**********

      void ~Fruits(){}//  定义析构函数

      bool  isFruit(char   *name)const;//  判断是否是参数所指定的水果

private:

      char  name[50]; //   水果名称

      float  price; //   水果价格

};

Fruits::Fruits(char *the_name,float  the_price)

{

      //ERROR**********found**********

      name=the_name;

      price=the_price;

}

bool  Fruits::isFruit(char *name)const

{

      //ERROR**********found**********

      return  (strcmp(name,name)==0);

}

int  main()

{

      Fruits  fruit1(苹果,3.00);

      Fruits  fruit2(梨,2.50);

      cout<<boolalpha;

      cout<<”fruit1  是苹果吗？”<<fruit1.isFruit(苹果)<<endl;

      cout<<”fruit1  是梨吗？”<<fruit1.isFruit(梨)<<endl;

      cout<<”fruit2  是苹果吗？”<<fruit2.isFruit(苹果)<<endl;

      cout<<”fruit2  是梨吗?”<<fruit2.isFruit(梨)<<endl;

      system(pause);

      return 0;

}

更正后程序的输出应该是：

 数组为：1 2 3 4 5 6 7 8 9 10

 各元素平均值为：5.5

[程序]

#include<iostream>

using namespace std;

class Array{

public:

 Array(int *p,int n); // 用p初始化a，用n初始化size

 void average(); // 求元素平均值

 void print(); // 按要求输出结果

 ~Array(); // 释放动态空间

private:

 int *a; // 数组

 int size; // 数组大小（元素个数）

 double mean; // 各元素的平均值

};

Array::Array(int *p,int n):size(n)

{

 int i;

 //ERROR**********found**********

 a=new int(size);

 for(i=0;i<size;i++)

 a[i]=p[i];

}

void Array::average()

{

 int i;

 //ERROR**********found**********

 double mean=0;

 for(i=0;i<size;i++)

 mean+=a[i];

 mean/=size;

}

void Array::print()

{

 int i;

 cout<<数组为：;

 for(i=0;i<size;i++)

 cout<<a[i]<< ;

 cout<<endl;

 cout<<各元素平均值为：<<mean<<\n;

}

Array::~Array()

{

 //ERROR**********found**********

 delete a;

}

int main()

{

 int t[10]={1,2,3,4,5,6,7,8,9,10};

 Array test(t,10);

 test.average();

 test.print();

 system(pause);

 return 0;

}

更正后程序的输出应该是：

 1+2=3

[程序]

#include<iostream>

using namespace std;

class Base{

public:

 Base(int x):m(x) { }

 int getm(){ return m;}

//ERROR**********found**********

private:

 int m;

};

//ERROR**********found**********

class Derived:protected Base{

public:

//ERROR**********found**********

 Derived(int x,int y):m(x),n(y) { }

 int getn(){ return n;}

 int getsum( ){ return m+n; }

private:

 int n;

};

int main()

{

 Derived test(1,2);

 cout<<test.getm()<<'+'<<test.getn()<<'='<<test.getsum()<<endl;

 system(pause);;

 return 0;

}

更正后程序的输出应该是：

 3 0 1 4 7 5 2 9 6 8

 奇数个数是：5

[程序]

#include<iostream>

using namespace std;

class MyClassA{

public:

 MyClassA(int *p,int n):length(n)

 {

 int i;

 //ERROR**********found**********

 arr=new int(length);

 for(i=0;i<length;i++)

 arr[i]=p[i];

 }

 int GetI(int i)const{ return arr[i];}

 int GetLength()const{ return length;}

 ~MyClassA(){ delete []arr; }

protected:

 int *arr; // 数组

 int length; // 元素个数

};

//ERROR**********found**********

class MyClassB: protected MyClassA{

public:

 MyClassB(int *p,int n);

 int GetI(int i)const;

 void count(); // 设置元素标记

 ~MyClassB();

private:

 int *arr; // 元素标记，1表示是奇数，0表示不是奇数

};

MyClassB::MyClassB(int *p,int n):MyClassA(p,n)

{

 arr=new int[length];

}

int MyClassB::GetI(int i)const{ return arr[i];}

void MyClassB::count()

{

 int i;

 for(i=0;i<length;i++)

 if(MyClassA::arr[i]%2==1)arr[i]=1;

 else arr[i]=0;

}

MyClassB::~MyClassB()

{

 delete []arr;

}

int main()

{

 int t[10]={3,0,1,4,7,5,2,9,6,8},i,s=0;

 MyClassB test(t,10);

 test.count();

 for(i=0;i<test.GetLength();i++){

//ERROR**********found**********

 cout<<test.GetI(i)<<'\t';

 s+=test.GetI(i);

 }

 cout<<endl;

 cout<<奇数个数是：;

 cout<<s<<endl;

 system(pause);

 return 0;

}

更正后程序的输出应该是：

 MyClassB::show()

 MyClassB::show()

[程序]

#include<iostream>

#include<cstring>

using namespace std;

class MyClassA{ // 基类

public:

 MyClassA()

 {

 strcpy(str,MyClassA::show());

 }

 //ERROR**********found**********

 void show()const

 {

 cout<<str<<endl;

 }

private:

 char str[100];

};

class MyClassB:public MyClassA{ // 派生类

public:

 MyClassB()

 {

 strcpy(s,MyClassB::show());

 }

 void show()const

 {

 cout<<s<<endl;

 }

private:

 char s[100];

};

//ERROR**********found**********

void fun(MyClassA t)

{

 t.show();

}

int main()

{

 MyClassB tb;

 fun(tb);

 MyClassA *ta=&amp;tb;

 //ERROR**********found**********

 ta.show(); // 通过ta调用show()

 system(pause);

 return 0;

}

更正后程序的输出应该是：

 100

[程序]

#include<iostream>

using namespace std;

class MyFriend{

public:

 MyFriend(int=0);

 void set(int);

 //ERROR**********found**********

 void print(MyFriend);

private:

 int member;

};

MyFriend::MyFriend(int m):member(m){}

void MyFriend::set(int m)

{

 member=m;

}

void print(MyFriend t)

{

 //ERROR**********found**********

 cout<<member<<endl;

}

int main()

{

 MyFriend test;

 test.set(100);

 //ERROR**********found**********

 test.print();

 system(pause);

 return 0;

}

更正后程序的输出应该是：

 5

 6

[程序]

#include<iostream>

using namespace std;

class Class_Friend{

public:

 Class_Friend(int x,int y):m1(x),m2(y) { }

 int GetSum();

 friend int GetPro(Class_Friend);

private:

 int m1,m2;

};

int Class_Friend::GetSum()

{

 return m1+m2;

}

//ERROR**********found**********

friend int GetPro(Class_Friend t)

{

 //ERROR**********found**********

 return m1*m2;

}

int main()

{

 Class_Friend test(2,3);

 cout<<test.GetSum()<<endl;

//ERROR**********found**********

 cout<<test.GetPro()<<endl;

 system(pause);;

 return 0;

}

更正后程序的输出应该是：

 点：(0,0)

 点：(1,2)

 距离：2.23607

 距离：2.23607

[程序]

#include<iostream>

#include<cmath>

using namespace std;

class Points{

public:

 Points(double xx=0.0,double yy=0.0); // 用参数初始化点的坐标

 double GetX()const; // 返回横坐标

 double GetY()const; // 返回纵坐标

 void print()const; // 输出点的坐标

 friend double distanceA(Points,Points);

private:

 double x,y; // 点的坐标

};

Points::Points(double xx,double yy):x(xx),y(yy){}

double Points::GetX( )const

{

 return x;

}

double Points::GetY()const

{

 return y;

}

void Points::print()const

{

 cout<<点：(<<x<<','<<y<<)\n;

}

//ERROR**********found**********

friend double Points ::distanceA(Points p1,Points p2)

{

 double dx,dy;

 dx=p1.x-p2.x;

 dy=p1.y-p2.y;

 return sqrt(dx*dx+dy*dy);

}

double distanceB(Points p1,Points p2)

{

 double dx,dy;

 //ERROR**********found**********

 dx=p1.x-p2.x;

 dy=p1.GetY()-p2.GetY();

 return sqrt(dx*dx+dy*dy);

}

int main()

{

 Points pa,pb(1.0,2.0);

 pa.print();

 pb.print();

//ERROR**********found**********

 cout<<距离：<<pa.distanceA(pa,pb)<<endl;

 cout<<距离：<<distanceB(pa,pb)<<endl;

 system(pause);

 return 0;

}

更正后程序的输出应该是：

 1+2=3

 1-2=-1

[程序]

#include<iostream>

using namespace std;

class MyClass{

public:

 MyClass(int t=0):m(t){ }

 //ERROR**********found**********

 MyClass operator+(MyClass,MyClass);

 friend MyClass operator-(MyClass);

 int Getm()const

 {

 return m;

 }

private:

 int m;

};

MyClass MyClass::operator+(MyClass t)

{

 return MyClass(m+t.m);

}

//ERROR**********found**********

MyClass MyClass::operator-(MyClass t1,MyClass t2)

{

//ERROR**********found**********

 return t1-t2;

}

int main()

{

 MyClass test1(1),test2(2),test3;

 test3=test1+test2;

 cout<<test1.Getm()<<+<<test2.Getm()<<'='<<test3.Getm()<<endl;

 test3=test1-test2;

 cout<<test1.Getm()<<-<<test2.Getm()<<'='<<test3.Getm()<<endl;

 system(pause);

 return 0;

}

此程序的正确输出结果应为：

 0.5^0=1

 0.5^1=0.5

 2^10=1024

 2^-3=0.125

[程序]

#include<iostream>

using namespace std;

class Powers{

public:

 void print(double,int); // 按指定格式输出结果

 double features(double x,int n);  // 用递归法求x的n次方的值，即xⁿ

};

//**********found**********

void _____(1)_______ print(double x,int n)

{

 //**********found********** 

 cout<<x<<'^'<<n<<'='<< _____(2)_______ <<endl;

}

double Powers::features(double x,int n)

{

 int k;

 if(n==0)return 1.0; // x的0次方为1

 else if(n==1)return x; // x的1次方为x

 else if(n<0){ // n<0时x的n次方的值

 //**********found**********

 ______(3)______ ;

 return 1/x*features(x,k);

 }

 else{ // n>0且n不为1时x的n次方的值

 k=n-1;

 //**********found**********

 return _____(4)_______ ;

 }

}

int main()

{

 Powers test;

 test.print(0.5,0);

 test.print(0.5,1);

 test.print(2,10);

 test.print(2,-3);

 return 0;

}

此程序的正确输出结果应为：

 一维数组为： 1 2 -3 -4 5 -6 -7 8

 负数元素和为：-20

 非负数元素和为：16

[程序]

#include<iostream>

using namespace std;

class Array{  // “数组”类

 double *a; // 存储数组的动态空间

 double s1,s2; // s1为负数元素之和，s2为非负数元素之和

 int length; // 数组中元素个数

public:

 Array(double *t,int n);

 void fun();

 void print();

 ~Array();

};

//**********found**********

Array::Array(double *t,int n)_________(1)_____________

{

 int i;

//**********found**********

 ___________(2)___________;

 for(i=0;i<n;i++)

 a[i]=t[i];

}

void Array::fun()

{

 for(int i=0;i<length;i++)

//**********found**********

 if( ______(3)______ )s1+=a[i];

 else s2+=*(a+i);

}

void Array::print()

{

 cout<<一维数组为：;

 for(int i=0;i<8;i++)

 cout<<a[i]<<'\t';

 cout<<endl;

 cout<<负数元素和为：;

 cout<<s1<<endl;

 cout<<非负数元素和为：;

 cout<<s2<<endl;

}

//**********found**********

___________(4)___________

{

 delete [] a;

}

int main(void )

{

 double t[8]={1,2,-3,-4,5,-6,-7,8};

 Array test(t,8);

 test.fun();

 test.print();

 system(pause);

 return 0;

}

此程序的正确输出结果应为：

 一维数组为： 3 9 6 9 5 9 8 2 9 7

 最大元素的值是：9，其所在位置分别是： 2 4 6 9

[程序]

#include<iostream>

using namespace std;

class Array{

 double *p; // 用p指向的动态空间存储要处理的一维数组

 double max; // max存放一维数组中元素的最大值

 int len; // len存放一维数组的大小（元素个数）

public:

 Array(double *t,int n); // 构造函数，用t初始化p，用n初始化len

 void f( ); // 求一维数组中元素的最大值

 void show(); // 输出一维数组、最大元素及其位置

//**********found**********

 _____(1)______ ; // 释放动态空间

};

Array::Array(double *t,int n): len(n)

{

 int i;

 p= new double[len];

 for(i=0;i<len;i++)

//**********found**********

 _____(2)______ ;

}

void Array::f( )

{

 int i;

//**********found**********

 ______(3)_____ ;

 for(i=1;i<len;i++)

 if(p[i]>max)max=p[i];

}

void Array::show()

{

 int i;

 cout<<一维数组为：;

 for(i=0;i<len;i++)

 cout<<p[i]<<'\t';

 cout<<\n最大元素的值是：<<max<<，其所在位置分别是：;

 for(i=0;i<len;i++)

 //**********found**********

 if(p[i]==max)cout<< _____ (4) ______ <<'\t';

 cout<<endl;

}

Array::~Array() { delete []p; }

int main(void)

{

 double t[]={3,9,6,9,5,9,8,2,9,7};

 Array test(t,sizeof(t)/8);

 test.f();

 test.show();

 system(pause);

 return 0;

}

此程序的正确输出结果应为：

 数组为：

 6 8 3 9 4 2 1 7 5

 x为：5

 比5大的元素个数为：4

[程序]

#include<iostream>

using namespace std;

class Array{

public:

 Array(float *p,int m,float x1); // 用p初始化a，m初始化n，x1初始化x

 ~Array(); // 释放动态空间

 void print()const; // 按指定格式输出结果

 void count(); // 计算比x大的元素个数

private:

 float *a,x; // 数组及指定的x

 int n; // 数组大小（所有元素个数）

 static int number; // 数组中比x大的元素个数

};

//**********found**********

____________(1)______________ ;

Array::Array(float *p,int m,float x1):n(m),x(x1)

{

 int i;

 //**********found**********

 ____________(2)______________ ;

 for(i=0;i<n;i++)

 a[i]=p[i];

}

Array::~Array()

{

 //**********found**********

 ____________(3)______________ ;

}

void Array::print()const

{

 int i;

 cout<<数组为：\n;

 for(i=0;i<n;i++)

 cout<<a[i]<<'\t';

 cout<<endl;

 cout<<x为：<<x<<endl;

 cout<<比<<x<<大的元素个数为：<<number<<endl;

}

void Array::count()

{

 int i;

 for(i=0;i<n;i++)

 //**********found**********

 ________(4)_________ number++;

}

int main()

{

 float t[9]={6,8,3,9,4,2,1,7,5};

 Array test(t,9,5.0);

 test.count();

 test.print();

 system(pause);

 return 0;

}

此程序的正确输出结果应为：

 原字符串为：123456789

 pos=5，用abcde替换后为：abcd56789

 pos=8，用abcde替换后为：abcde89

[程序]

#include<iostream>

#include<cstring>

using namespace std;

class STRING{

public:

 STRING(char *s);

 ~STRING();

 void replace(char*s,int pos); // 按题意用s替换pos前的字符

 char* get()const; // 取出字符串

private:

 char *str; // 存储字符串的动态空间

};

STRING::STRING(char *s)

{

 //**********found**********

 ____________(1)______________ ; // 分配动态空间

 strcpy(str,s);

}

STRING::~STRING()

{

 //**********found**********

 _______(2)_______; // 释放动态空间

}

void STRING::replace(char*s,int pos)

{

 int i,j=pos-1;

 if(strlen(s)>=pos)

 for(i=0;i<j;i++)  // 复制字符串s

 str[i]=s[i];

 else{

 char *ss=new char[strlen(str)+strlen(s)-pos+2];

 for(i=0;s[i];i++) // 复制字符串s

 ss[i]=s[i];

 //**********found**********

 while( ____(3)____ ){ // 复制指定位置的字符串

 ss[i]=str[j];

 i++;

 j++;

 }

 ss[i]='@';

 delete []str;

 //**********found**********

 ______(4)______ ; // 将替换后的字符串ss作为数据成员str

 }

}

char* STRING::get()const

{

 return str;

}

int main(void )

{

 int pos;

 char *s=abcde;

 STRING t1(123456789),t2(123456789);

 cout<<原字符串为：<<t1.get()<<endl;

 pos=5;

 t1.replace(s,pos);

 cout<<pos=<<pos<<，用<<s<<替换后为：<<t1.get()<<endl;

 cout<<原字符串为：<<t2.get()<<endl;

 pos=8;

 t2.replace(s,pos);

 cout<<pos=<<pos<<，用<<s<<替换后为：<<t2.get()<<endl;

 system(pause);

 return 0;

}

对于主函数中给定的测试数据，程序的正确输出结果应为：

 桃开花时间是：2020-3-10

 杏开花时间是：2020-4-5

 桃和杏不在同一天开花。

[程序]

#include<iostream>

using namespace std;

class Dates{

public:

 Dates(int y=0,int m=0,int d=0):year(y),month(m),day(d){ }

 ~Dates(){ }

 int GetYear(){return year;}

 int GetMonth(){return month;}

 int GetDay(){return day;}

private:

//**********found**********

 ____________(1)______________ ; // 开花日期（年月日）

};

class Plants:public Dates{

public:

 Plants(char*n,int y=0,int m=0,int d=0);

 ~Plants();

 char*GetName();

private:

 char *name; // 植物名称

};

//**********found**********

Plants::Plants(char*n,int y,int m,int d): _________(2)_____________

{

 int length;

 length=strlen(n);

 name=new char[length+1];

 strcpy_s(name,length+1,n);

}

Plants::~Plants()

{

 delete []name;

}

char* Plants::GetName()

{

//**********found**********

 return ________(3)___________ ;

}

bool IsEqual(Plants &amp;pa,Plants &amp;pb) // 判断pa和pb开花日期是否相同，是返回真，否则返回假

{

 if(pa.GetYear()==pb.GetYear())

//**********found**********

 if( ___________(4)____________ )

 if(pa.GetDay()==pb.GetDay())return true;

 return false;

}

int main()

{

 Plants plantA(桃,2020,3,10);

 Plants plantB(杏,2020,4,5);

 cout<<plantA.GetName()<<开花时间是：<<plantA.GetYear()<<'-'<<plantA.GetMonth()<<'-'<<plantA.GetDay()<<endl;

 cout<<plantB.GetName()<<开花时间是：<<plantB.GetYear()<<'-'<<plantB.GetMonth()<<'-'<<plantB.GetDay()<<endl;

 if(IsEqual(plantA,plantB))

 cout<<plantA.GetName()<<和<<plantB.GetName()<<在同一天开花。<<endl;

 else cout<<plantA.GetName()<<和<<plantB.GetName()<<不在同一天开花。<<endl;

 system(pause);

 return 0;

}

输出结果为：

 桃和杏不在同一天开花。

[程序]

#include<iostream>

using namespace std;

class Date{

public:

 Date(int y=0,int m=0,int d=0):year(y),month(m),day(d){ }

 ~Date(){ }

 // 比较date1和date2，若二者相同，则返回true，否则返回false

 friend bool isEqual(Date date1,Date date2);

private:

 //**********found**********

 ____________(1)______________ ; // 开花日期（年月日）

};

class Plants{

public:

 Plants(char*n,Date d);

 ~Plants();

 Date getDate();

 char*GetName();

private:

 char *name; // 植物名称

 Date date; // 该植物的开花日期

};

bool isEqual(Date date1,Date date2)

{

 //**********found**********

 return ____________________(2)________________________________;

}

Plants::Plants(char*n,Date d)

{

 int length;

 length=strlen(n);

 //**********found**********

 ____________(3)______________;

 strcpy_s(name,length+1,n);

 date=d;

}

Plants::~Plants()

{

 if(name)

 //**********found**********

 __________(4)_________ ;

}

Date Plants::getDate()

{

 return date;

}

char* Plants::GetName()

{

 return name ;

}

int main()

{

 Plants plantA(桃,Date(2009,3,10));

 Plants plantB(杏,Date(2009,4,5));

 if(isEqual(plantA.getDate(),plantB.getDate()))

 cout<<plantA.GetName()<<和<<plantB.GetName()<<在同一天开花。<<endl;

 else cout<<plantA.GetName()<<和<<plantB.GetName()<<不在同一天开花。<<endl;

 system(pause);

 return 0;

}

此程序的正确输出结果应为（下划线部分为键盘输入内容）：

 设置整型数组大小： 8 

 输入整型数组： 1 2 3 4 5 6 7 8

 整型数组为：1,2,3,4,5,6,7,8

 设置字符数组大小： 16 

 输入字符数组： I am a student.

 字符数组为：I am a student.

[程序]

#include<iostream>

#include<cstring>

using namespace std;

class Array{ // 数组类

public:

 Array(int n):length(n){ }

 //**********found**********

 ____________(1)_______________ ; // 输入数组

 virtual void output()const=0; // 输出数组

protected:

 int length; // 数组大小（元素个数）

};

class IntArray:public Array{ // 整型数组类

public:

 IntArray(int n):Array(n)

 {

 arr=new int[length];

 }

 //**********found**********

 ____________(2)_______________

 void input()

 {

 int i;

 cout<<输入整型数组：;

 for(i=0;i<length;i++)

 cin>>arr[i];

 }

 void output()const

 {

 int i;

 cout<<整型数组为：;

 for(i=0;i<length;i++)

 if(i==length-1)cout<<arr[i]<<endl;

 //**********found**********

 else __________(3)_________________;

 }

private:

 int *arr;

};

class CharArray:public Array{ // 字符数组类

public:

 //**********found**********

 CharArray(int n): _______(4)________

 {

 arr=new char[length];

 }

 ~CharArray(){ delete []arr; }

 void input()

 {

 char c;

 cin.get(c); // 清除缓存中的换行符

 cout<<输入字符数组：;

 cin.getline(arr,length);

 }

 void output()const

 {

 cout<<字符数组为：;

 cout<<arr<<endl;

 }

private:

 char *arr;

};

void fun(Array *p)

{

 p->input();

 p->output();

}

void fun(Array *p)

{

 p->input();

 p->output();

}

int main(void )

{

 int n;

 cout<<设置整型数组大小：;

 cin>>n;

 IntArray test1(n);

 fun(&amp;test1);

 cout<<设置字符数组大小：;

 cin>>n;

 CharArray test2(n);

 fun(&amp;test2);

 system(pause);

 return 0;

}