使用VC6打开考生文件夹下的工程test25_1，此工程包含一个源程序文件test25_1.cpp，但该程序运行有问题，请改正程序中的错误，使程序的输出结果如下：privatel from derived1:30privatel from derived2:30源程序文件test25_1.cpp清单如下：/***************found******************/include＜iostream.h＞class base{protected:int privatel;public:ba
题目
使用VC6打开考生文件夹下的工程test25_1，此工程包含一个源程序文件test25_1.cpp，但该程序运行有问题，请改正程序中的错误，使程序的输出结果如下：
privatel from derived1:30
privatel from derived2:30
源程序文件test25_1.cpp清单如下：
/***************found******************/
include＜iostream.h＞
class base
{
protected:
int privatel;
public:
base(int p){privatel=p;}
};
/****************found*******************/
class derived1:public base
{
public:
derivedl(int p1):base(p1){};
int get_private(){return private1;}
}
class derived2:virtua1 public base
{
public:
derived2(int p2):base(p2){};
int get_private(){return private1;}
};
class derived12:public derived1,public derived2
{
public:
/****************found*******************/
derived12(int p1,int p2,int pb):derived1(p1), base(pb), derived2(p2){};
};
void main()
{
derived12 d(10,20,30);
cout＜＜"privatel from derived1:"＜＜d.derived1::get_private();
cout＜＜"\nprivatel from derived2:"＜＜d.derived2::get_private();
cout＜＜endl;
相似考题
更多“使用VC6打开考生文件夹下的工程test25_1，此工程包含一个源程序文件test25_1.cpp，但该程序运行有问题，请改正程序中的错误，使程序的输出结果如下：privatel from derived1:30privatel from derived2:30源程序文件test25_1.cpp清单如下：/***************found******************/include＜iostream.h＞class base{protected:int privatel;public:ba”相关问题
-
第1题：
使用VC6打开考生文件夹下的工程test7_1，此工程包含一个源程序文件test7_1.cpp，但该程序运行有问题，请改正程序中的错误，使程序的输出结果如下：
Constructor1
Constructor1
Constructor1
Destructor
Constructor2
Destructor
x=0
x=5
Destructor
Destructor
源程序文件test1_1.cpp清单如下：
include＜iostream.h＞
class B
{
int X;
public：
B(){X=0;cout＜＜"Constructorl"＜＜endl;}
B(int i){x=i;cout＜＜"Constructor2"＜＜endl;}
～B(){cout＜＜"Destructor"＜＜endl;}
／**********found*********／
～B(int i){cout＜＜i＜＜"be Destructor"＜＜endl;}
void print(){cout＜＜"x="＜＜x＜＜endl;}
};
void main()
{
B *ptr;
ptr=new B[2];
／**********found*********／
ptr[0]=B(0);
ptr[1]=B(5);
／**********found********／
for(int i=0; i＜2;)
ptr[i].print();
delete []ptr;
}
正确答案：(1)错误：～B(int i){cout"be Destructor"endl;} 正确：应将其删除 (2)错误：ptr[0]=B(0); 正确：ptr[0]=B(); (3)错误：for(int=0;i2;) 正确：for(int i=0;i2;i++)
(1)错误：～B(int i){cout"be Destructor"endl;} 正确：应将其删除 (2)错误：ptr[0]=B(0); 正确：ptr[0]=B(); (3)错误：for(int=0;i2;) 正确：for(int i=0;i2;i++) 解析：(1)主要考查考生对析构函数特性的掌握，析构函数不能带参数也不能重载，一个类中只能定义一个析构函数，因为析构函数在删除对象的时候被默认调用，如果含有多个析构函数则可能引起多次删除产生的意外错误;
(2)主要考查考生对构造函数与函数重载的掌握，由输出结果可知其应该调用不带参数的构造函数B()；
(3)主要考查考生对for循环语句的使用，如果在for循环中不写第三个表达式就意味着该循环一直会进行下去，因为 i的值总是小于2(在for循环体中对i进行操作也可以)。 -
第2题：
使用VC6打开考生文件夹下的工程test42_1，此工程包含一个源程序文件test42_1.cpp，但该程序运行有问题，请改正函数中的错误，使该程序的输出结果为：
rect area: 12
rectb area: 30
源程序文件test42_1.cpp清单如下：
include ＜iostream.h＞
class CRectangle
{
/***************** found *****************/
int *width, height;
public:
CRectangle (int,int);
～CRectangle ();
int area (void) {return (*width * *height);}
};
CRectangle::CRectangle (int a, int b)
{
width = new int;
height = new int;
/***************** found *****************/
width = a;
*height = b;
}
CRectangle::～CRectangle ()
{
delete width;
delete height;
}
/***************** found *****************/
void main ()
{
CRectangle rect (3,4), rectb (5,6);
cout ＜＜ "rect area: "＜＜ rect.area() ＜＜ endl;
cout ＜＜ "rectb area: "＜＜ rectb.area() ＜＜ endl;
return 0;
}
正确答案：(1) 错误：int*widthheight； 正确：int*width*height； (2) 错误：width=a； 正确：*width=a； (3) 错误：void main() 正确；int main()
(1) 错误：int*width，height； 正确：int*width，*height； (2) 错误：width=a； 正确：*width=a； (3) 错误：void main() 正确；int main() 解析：(1)根据后面类中构造函数的定义可以看出只有定义成指针的变量才能动态申请空间，所以本题的错误在于没有把变量 height定义成指针类型；
(2)变量width是指针类型的变量，直接给它赋值相当于让它指向一个新的地址，而要改变它指向的变量的值，应该使用取内容符号“*”：
(3)根据主函数最后的返回值情况，可知该主函数是需要定义成带返回值的函数，本题的错误在于，把主函数定义成了void，改成int即可，考生一定要注意函数定义的返回值和最后实际的返回情况是否一一对应。 -
第3题：
使用VC6打开考生文件夹下的工程test17_1，此工程包含一个源程序文件test17_1．唧，但该程序运行有问题，请改正程序中的错误，使程序的输出结果如下：
Vehicle message
Car message
Vehicle message
源程序文件test17_1.cpp 清单如下:
include ＜iostream.h＞
class vehicle
{
int wheels;
float weight;
public:
/***************** found *****************/
void message(void){ cout＜＜"Vehicle message\n";}
};
class car:public vehicle
{
int passenger_load;
public:
/***************** found *****************/
void message (void){cout＞＞"Car message\n";}
};
class truck:public vehicle
{
int passenger_load;
float payload;
public:
int passengers(void){return passenger_load;}
};
void main()
{
vehicle * unicycle;
unicycle=new vehicle;
/***************** found *****************/
unicycle.message()
delete unicycle;
unicycle=new car;
unicycle-＞message();
delete unicycle;
unicycle=new truck;
unicycle-＞message();
delete unicycle;
}
正确答案：(1)错误：void message(void){cout"Vehicle message\n"；} 正确：virtual void message(void){cout"Vehicle message\n"；} (2)错误：void message(void){cout＞＞"Carmessage\n”；} 正确：void message(void){eout"Carmessage\n"；} (3)错误：unicycle．message()； 正确：unicycle-＞message()；
(1)错误：void message(void){cout"Vehicle message\n"；} 正确：virtual void message(void){cout"Vehicle message\n"；} (2)错误：void message(void){cout＞＞"Carmessage\n”；} 正确：void message(void){eout"Carmessage\n"；} (3)错误：unicycle．message()； 正确：unicycle-＞message()； 解析：(1)主要考查考生对于虚函数使用规则的掌握，要实现对函数message的动态联编应该使用虚函数，否则产生的是静态联编，调用的函数输出结果就与要求不符；
(2)主要考查考生对于流输出操作的掌握，该处错误的使用了流输入操作；
(3)主要考查考生是否能分清对象和对象指针，对象指针使用“-＞”调用成员函数，而对象使用“．”调用成员函数。 -
第4题：
使用VC6打开考生文件夹下的工程test30_1，此工程包含一个源程序文件test30_1.cpp，但该程序运行有问题，请改正程序中的错误，使该程序的输出结果为：
Previous=9，Next=11
源程序文件test30_1.cpp清单如下：
include ＜iostream.h＞
/***************** found *****************/
void prevnext (int,int &,int&);
int main ( )
{
int x=10,y,z;
prevnext (x,y,z);
cout ＜＜ "Previous=" ＜＜ y ＜＜ ", Next=" ＜＜ z＜＜end1;
return 0;
}
/***************** found *****************/
void prevnext (int x, int prev, int next)
{
/***************** found *****************/
prev=x--;
next=++x;
}
正确答案：(1)错误：在main()函数前缺少prevnext函数的声明 正确：void prevnext(intint &int &)； (2)错误：void prevnext(int xint prevint next) 正确：void prevnext(int xint &prevint &next) (3)错误：prev=x--； 正确：prev=x-1；
(1)错误：在main()函数前缺少prevnext函数的声明 正确：void prevnext(int,int &,int &)； (2)错误：void prevnext(int x，int prev,int next) 正确：void prevnext(int x,int &prev,int &next) (3)错误：prev=x--； 正确：prev=x-1； 解析：(1)函数在使用前必须已经被定义，main()中调用prevnext函数，而该函数的实现在main()之后，所以在main()之前必须添加该函数的声明；
(2)由运行结果可知，通过函数prevnext调动要改变main()中的实参值，所以prey和next都应为引用型参数：
(3)由运行结果prev=x-1，而源程序的prev=x，x=x-1，这里涉及的是运算符的优先级问题。 -
第5题：
使用VC6打开考生文件夹下的工程test29_1，此工程包含一个源程序文件test29_1.cpp，但该程序运行有问题，请改正程序中的错误，使该程序的输出结果为：
A：no parameters
B：int parameter
A：no parameters
B：int parameter
C：int parameter
源程序文件test29_1.cpp清单如下；
include ＜iostream.h＞
class A
{
/***************** found *****************/
private:
A(){ cout＜＜"A:no parameters\n";}
A(int a) {cout＜＜"A: int parameter\n";}
};
class B:public A
{
public:
B(int a){cout＜＜"B:int Parameter\n";}
};
/***************** found *****************/
class C:public B,public A
{
public:
/***************** found *****************/
C(int a) ::B(a) {cout＜＜"C: int parameter\n"; )
};
void main ( )
{
B b(1);
C c(2);
}
正确答案：(1)错误：private： 正确：public： (2)错误：class C：public Bpublic A 正确：class C：public B (3)错误：C(int a)：：B(a){cout"C：int parameter\n"；) 正确：C(int a)：B(a){cout"C：int parameter\n"；}
(1)错误：private： 正确：public： (2)错误：class C：public B,public A 正确：class C：public B (3)错误：C(int a)：：B(a){cout"C：int parameter\n"；) 正确：C(int a)：B(a){cout"C：int parameter\n"；} 解析：(1)一个类的构造函数和析构函数可以由系统自动生成，也可以由用户提供，但构造函数和析构函数都必须是该类的公有成员函数，否则编译时将出现错误，不能被调用；
(2)A已经是B的基类，C公有继承B，A也就成为了C的基类，根据程序的运行结果可知，C是要公有继承B；
(3)派生类的构造函数，初始化基类的参数，调用基类的构造函数时，使用符号“：”，而不是“：：”； -
第6题：
使用VC6打开考生文件夹下的工程test38_1，此工程包含一个源程序文件test38_1.cpp，但该程序运行有问题，请改正函数中的错误，使该程序的输出结果为：
2 is a factor of 10
源程序文件test38_1.cpp清单如下：
include ＜iostream.h＞
class myclass
{
/***************** found *****************/
int n,d
public:
myclass(int i, int j){ n=i; d=j; }
friend int factor( myclass ob);
};
/***************** found *****************/
int myclass::factor(myclass ob)
{
/***************** found *****************/
if(ob.n%ob.d)
return 1;
else
return 0;
}
void main()
{
myclass ob1(10,2),ob2(13,3);
if(factor(ob1))
cout＜＜"2 is a factor of 10\n";
if(factor(ob2))
cout＜＜"3 is not a factor of 13\n";
}
正确答案：(1) 错误：int nd 正确；int nd； (2) 错误：int myclass::factor(myclass ob) 正确：int factor(myclass ob) (3) 错误：if(ob.n%ob.d) 正确：if(ob.n%ob.d))
(1) 错误：int n，d 正确；int n，d； (2) 错误：int myclass::factor(myclass ob) 正确：int factor(myclass ob) (3) 错误：if(ob.n%ob.d) 正确：if(ob.n%ob.d)) 解析：(1)主要考查考生对于变量定义的理解，同类型的变量定义中间使用逗号分开，同时可以进行初始化，但是在整个定义的结尾必须使用分号，这是C++的规定：
(2)主要考查考生是否掌握了友元函数的定义，友元是在类的内部声明，类的外部实现的一种特殊的函数，它可以访问类内的所有成员，不过在类外的实现和调用的时候均不需要使用作用域符号“::”限制：
(3)主要考查考生对于if条件语句的掌握，只有括号内的条件为真，即值为1时，才执行if后面的语句，根据题目要求应该执行的是对象ob1，即2可以整除10，所以应该定义函数factor的返回值为能整除返回1，否则为0，而能够整除即取余运算值为0，所以在判断前应该加上非运算。 -
第7题：
使用VC6打开考生文件夹下的工程test23_1，此工程包含一个源程序文件test23_1.cpp，但该程序运行有问题，请改正程序中的错误，使程序的输出结果如下:
i
iz
O
12
22
源程序文件test23_1.cpp清单如下：
include＜iostream.h＞
include＜stdio.h＞
class innerclass
{
int x;
public:
/****************found*******************/
innerclass(int z) { x=z; cout＜＜"iz"＜＜endl;};
/****************found*******************/
void write( ) {print("%d\n",x);}
}
class outerclass
{
int y;
innerclass g;
innerclass *h;
public:
outerclass(int a);
void write( ) { printf("%d\n",y); }
void write_inner_g() {g.write(); }
void write_inner_h() {h-＞write();}
};
outerclass::outerclass(int a)
{
/****************found*******************/
h=new innerclass(12);
cout＜＜"o"＜＜endl;
}
int main ( )
{
outerclass ob(22);
ob.write_inner_h();
ob.write();
return 1;
}
正确答案：(1)错误：缺少缺省的构造函数 正确：innerclass(){cout"i"endl；} (2)错误：void write(){print("%d\n"x)；} 正确：void write(){printf("%d\n"x)；} (3)错误：缺少赋值语句 正确：y=a；
(1)错误：缺少缺省的构造函数 正确：innerclass(){cout"i"endl；} (2)错误：void write(){print("%d\n",x)；} 正确：void write(){printf("%d\n",x)；} (3)错误：缺少赋值语句 正确：y=a； 解析：(1)主要考查考生对于派生类调用基类构造函数的应用，此处必须定义缺省的构造函数(g调用)；
(2)主要考查考生对于格式化输出的掌握，应该使用函数printf，其中的%d表示是输出整型：
(3)主要考查考生对于构造函数作用的掌握，只有在此处赋值才能将22显示出来，因为构造函数在声明对象的时候会被自动的调用。 -
第8题：
使用VC6打开考生文件夹下的工程test34_1，此工程包含一个源程序文件test34_1.cpp，但该程序运行有问题，请改正程序中的错误，使该程序的输出结果为：
David 3123 1000
源程序文件test34_1.cpp清单如下：
include ＜iostream.h＞
include ＜string.h＞
class person
{
public:
char name[20];
unsigned long id;
float salary;
void print(){cout＜＜name＜＜' '＜＜id＜＜' '＜＜salary＜＜
/***************** found *****************/
}
void main( )
{
person p;
person *ptr;
/***************** found *****************/
ptr=p;
/***************** found *****************/
strcpy("David",ptr-＞name);
ptr-＞id=3123;
ptr-＞salary=1000;
ptr-＞print();
}
正确答案：(1)错误：} 正确：}； (2)错误：ptr=p； 正确：ptr=&p； (3)错误：strcpy("David"ptr＞name)； 正确：strcpy(ptr-＞name"David")；
(1)错误：} 正确：}； (2)错误：ptr=p； 正确：ptr=&p； (3)错误：strcpy("David",ptr＞name)； 正确：strcpy(ptr-＞name,"David")； 解析：(1)类定义的一般格式为：
class类名＞
{
pubic：
数据成员或成员函数的说明＞
private：
数据成员或成员函数的说明＞
protected：
数据成员或成员函数的说明＞
}；
花括号表示类的声明范围，说明该类的成员，其后的分号表示类声明结束，类声明最后的分号是不可少的；
(2)p为类person的对象，ptr为指向类person对象的指针，所以将p的值赋给ptr应该为ptr=&p，即ptr指向对象p；
(3)strcpy()函数的一般形式为：
strcpy(to,from)；
该函数将from字符串中的内容复制到to字符串，所以将字符串“David”赋值给ptr所指对象的数据成员name的语句应该为：
strcpy(ptr-＞name，"David")。 -
第9题：
使用VC6打开考生文件夹下的工程test21_1，此工程包含一个源程序文件test21_1.cpp，但该程序运行有问题，请改正程序中的错误，使程序的输出结果如下：
The grade is 3
源程序文件test21_1.cpp清单如下：
include＜iostream.h＞
class student
{
private：
int grade；
public:
/**************** found*******************/
student(int thegra):(thegra){}
～student(){}
int get_grade(){return grade；}
}；
void main()
{
int thegra=3；
/**************** found*******************/
student point=new student(thegra)；
/**************** found*******************/
cout＜＜"The grade is"＜＜point.get_grade()＜＜endl；
delete point；
}
正确答案：(1)错误:student(int thegra):(thegra){} 正确:student(int thegra):grade(thegra){} (2)错误:student point=new student(thegra) 正确:student*point=new student(thegra)； (3)错误:cout"The grade is"point.get_grade()endl； 正确:cout"The grade is"point-＞get_grade()endl；
(1)错误:student(int thegra):(thegra){} 正确:student(int thegra):grade(thegra){} (2)错误:student point=new student(thegra) 正确:student*point=new student(thegra)； (3)错误:cout"The grade is"point.get_grade()endl； 正确:cout"The grade is"point-＞get_grade()endl； 解析：(1)主要考查考生对于构造函数使用参数列表初始化数据成员的掌握，可以使用参数列表的形式，也可以在函数内部实现，不过参数赋值的双方都必须出现，本题的错误就在于并没有把参数赋值给数据成员；
(2)主要考查考生对于使用指针申请动态空间的方法的理解，new运算符申请的空间返回值为指针类型，指针类型的定义是在变量名前加上“*”；
(3)主要考查考生对于对象指针调用成员函数方法的掌握，必须使用符号“-＞”，而对象本身使用符号“.”。 -
第10题：
使用VC6打开考生文件夹下的工程test36_1，此工程包含一个源程序文件test36_1.cpp，但该程序运行有问题，请改正函数中的错误，使该程序的输出结果为：
2
源程序文件test36_1.cpp清单如下：
include＜iostream.h＞
class amount;
class coins
{
/***************** found *****************/
enum units {penny, nickel, dime, quarter, half_dollar}
/***************** found *****************/
class amount;
};
class amount
{
/***************** found *****************/
coins:units money;
public:
void setm();
int germ();
};
void amount::setm()
{
money = coins::dime;
}
int amount::getm()
{
return money;
}
int main ( )
{
amount ob;
ob.setm();
cout ＜＜ ob.getm()＜＜end1;
return 0;
}
正确答案：(1) 错误；enum units{pennynickeldimequarterhalf_dollar} 正确：enum units {pennynickeldimequarterhalf_dollar}; (2) 错误：class amount； 正确：friend class amount； (3) 错误：coins:units money； 正确：coins：：units money；
(1) 错误；enum units{penny，nickel，dime，quarter,half_dollar} 正确：enum units {penny，nickel，dime，quarter，half_dollar}; (2) 错误：class amount； 正确：friend class amount； (3) 错误：coins:units money； 正确：coins：：units money； 解析：(1)enum是枚举类型，units是本题中该类型的一个变量，后面为枚举表，大括号中为枚举符，枚举变量的值实际上是一个有名字的常量，所以它的定义结束时也需要一个分号；
(2)类amount是类coins中定义的成员，要是想要访问coins类中的私有成员，把amount定义成普通的数据成员是不能做到的，只能把它定义成友元类，即可以访问coins类中的所有成员(提示：units是使用的默认定义，即私有成员)；
(3)units是类coins中的成员，在它的友元类中访问它时应该使用作用域符“：：”，本题的错误是使用了冒号。 -
第11题：
使用VC6打开考生文件夹下的工程test41_1，此工程包含一个源程序文件test41_1.cpp，但该程序运行有问题，请改正函数中的错误，使该程序的输出结果为：
7
源程序文件test41_1.cpp清单如下：
include＜iostream.h＞
class myclass
{
int a, b;
public:
/***************** found *****************/
int sum(myclass x);
void set_ab(int i, int j);
}:
/**************** found ****************/
void myclass:set_ab(int i, int j)
{
a=i;
b=j;
}
int sum (myclass x)
{
/***************** found ***************/
x.a+x.b;
}
void main ( )
{
myclass n;
n.set_ab (3, 4);
cout ＜＜sum(n)＜＜endl;
}
正确答案：(1) 错误：int sum(myclass x)； 正确：friend int sum(myclass x)； (2) 错误：void myclass:set_ab(int iint j) 正确：void myclass::set_ab(int iint j) (3) 错误：x.a+x.b; 正确：return x.a+x.b;
(1) 错误：int sum(myclass x)； 正确：friend int sum(myclass x)； (2) 错误：void myclass:set_ab(int i，int j) 正确：void myclass::set_ab(int i，int j) (3) 错误：x.a+x.b; 正确：return x.a+x.b; 解析：(1)函数sum中含有对于myclass类的私有数据成员a和b的操作，而普通函数没有这样的权限，所以编译器会报错，只有把sum定义成该类的友元函数，这样根据友元函数可以访问该类的所有元素的规则，就可以正确地实现该函数：
(2)函数的参数列表只能用于类的构造函数，对于构造函数，参数列表与在函数体内赋值是等价的，但是一般的类的成员函数只能使用函数体内赋值一种方法；
(3)该函数的返回值为int型，所以计算之后的结果应该使用关键字return返回主函数，return返回值可以使用括号，也可以不使用，后面可以是表达式也可以是变量或者常量。 -
第12题：
使用VC6打开考生文件夹下的工程test15_1，此工程包含一个源程序文件test15_1.cpp，但该程序运行有问题，请改正程序中的错误，使该程序的输出结果如下：
My object has member 7
源程序文件test15_1.cpp清单如下：
include＜iostream.h＞
class MyClass
{
public：
MyClass(int mem){member=mem；}
～MyClass(){}
int GetAge()const{ return member；}
private：
int member；
}；
/*****+********+** found *************/
void main()
{
int mem=7；
/*************** found ***************/
MyClass myObj=MakeObject(mem)；
cout＜＜"My object has member"＜＜myObj-＞GetAge()＜＜endl；
/***************** found ****************/
delete；
}
MyClass *MakeObject(int mem)
{
MyClass *pMyClass=new MyClass(mem)；
return pMyClass；
}
正确答案：(1)添加函数定义MyClass*MakeObject(int mem)； (2)错误：MyClass myObj=MakeObject(mem)； 正确：MyClass *myObj=MakeObject(mem)； (3)错误：delete； 正确：delete myObj；
(1)添加函数定义MyClass*MakeObject(int mem)； (2)错误：MyClass myObj=MakeObject(mem)； 正确：MyClass *myObj=MakeObject(mem)； (3)错误：delete； 正确：delete myObj； 解析：(1)主要考查考生对于函数定义规则的理解，在使用前先定义，这是规定；
(2)主要考查考生对于指针的掌握，因为函数返回值为指针，所以返回值必须赋值给一个指针类型的变量；
(3)主要考查考生是否会使用delete释放空间，使用delete删除一个指针时，只需要直接把指针变量的名称写在后面。 -
第13题：
使用VC6打开考生文件夹下的工程test10_1，此工程包含一个源程序文件test10_1.cpp，但该程序运行有问题，请改正程序中的错误，使程序的输出结果为；
class Base
class D1
class D2
class D3
fin Base
源程序文件test10_1.cpp清单如下：
include＜iostream.h＞
class Base
{
public:
Base(){cout＜＜"class Base"＜＜endl;}
void f(){cout＜＜"f in Base"＜＜endl;}
};
class D1:virtual public Base
{
public:
D1(){cout＜＜"class D1"＜＜endl;}
void f(){cout＜＜"f in D1"＜＜endl;}
};
／*********found**********／
class D2:public Base
{
public:
D2(){cout＜＜"class D2"＜＜endl;}
／**********found**********／
class D3::public D1，public D2
{
public:
D3(){cout＜＜"class D3"＜＜endl;}
};
void main()
{
D3 d;
／**********found************／
d.f();
}
正确答案：(1)错误：class D2:public Base 正确：class D2:virtual public Base (2)错误：class D3::public D1public D2 正确：class D3:public D1public D2 (3)错误：d.f(); 正确：d.Base::f();
(1)错误：class D2:public Base 正确：class D2:virtual public Base (2)错误：class D3::public D1,public D2 正确：class D3:public D1,public D2 (3)错误：d.f(); 正确：d.Base::f(); 解析：(1)主要考查考生对虚基类的理解，虚基类可以解决二义性的问题，其定义方式是在继承列表中使用virtual关键字，使用虚基类可以避免程序运行中对基类函数调用的不惟一；
(2)主要考查考生对类的定义方法的掌握，“::”为作用域符，此处应该使用“:”，因为后面是继承列表；
(3)主要考查考生对虚基类函数调用过程的理解，只有使用“:”限定才能访问基类函数，否则将会调用自身的函数，如果该类没有该函数的定义，则会自动调用其父类的该函数，所以必须使用“::”符号。 -
第14题：
使用VC6打开老考生文件夹下的工程test5_1，此工程包含一个源程序文件test5_1.cpp，但该程序运行有问题，请改正程序中的错误，使程序的输出结果如下：
x=3 y=5 z=0
8
源程序文件test5_1.cpp清单如下：
include＜iostream.h＞
static int x=5;
int z=0;
int *add(int x,int y)
{
cout＜＜"X="＜＜X＜＜"y="＜＜y＜＜" Z="＜＜z＜＜endl;
z=z+x+y;
／********found*********／
return z;
／********found*********／
};
void main()
{
int y=5;
int x=3;
／*********found********／
cout＜＜&(add(X,y))＜＜endl;
}
正确答案：(1)错误：return z; 正确：return &z; (2)错误：}; 正确：} (3)错误：cout&(add(xy))endl; 正确：cout*(add(xy))endl;
(1)错误：return z; 正确：return &z; (2)错误：}; 正确：} (3)错误：cout&(add(x,y))endl; 正确：cout*(add(x,y))endl; 解析：(1)主要考查考生对于函数返回类型的掌握，该函数的返回值应该是指向int型的指针，所以应该将地址作为返回值：
(2)主要考查考生对于类定义格式与函数定义格式区别的掌握，类的定义最后应该使用“;”而函数不需要用“;”；
(3)主要考查考生对于有返回值的函数调用的掌握，函数定义是返回指针型的，调用的时候就应该使用取地址符号。 -
第15题：
使用VC6打开考生文件夹下的工程test13_1，此工程包含一个源程序文件test13_1.cpp，但该程序运行有问题，请改正程序中的错误，使该程序的输出结果如下：
n=2
n=5
n=7
源程序文件test13_1清单如下：
include＜iostream.h＞
class Sample
{
int n；
public：
/*************** found ************+***/
Sample()
Sample(int i){n=i；}
/***************** found ********+**********/
void add(Sample s1，Sample s2)
/***************** found ****************/
{
this.n=s1-＞n+s2.n；
}
void disp(){cout＜＜"n="＜＜n＜＜endl；}
}；
void main()
{
Sample s1(2)，s2(5)，s3；
s3.add(&s1，s2)；
s1.disp()；
s2.disp()；
s3.disp()；
}
正确答案：(1)错误：Sample() 正确：Sample(){} (2)错误：void add(Sample s1Sample s2) 正确：void add(Sample *s1Sample s2) (3)错误：this.n=s1-＞n+s2.n； 正确：this-＞n=s1-＞n+s2.n；
(1)错误：Sample() 正确：Sample(){} (2)错误：void add(Sample s1,Sample s2) 正确：void add(Sample *s1,Sample s2) (3)错误：this.n=s1-＞n+s2.n； 正确：this-＞n=s1-＞n+s2.n； 解析：(1)主要考查考生对于类的成员函数定义的掌握，应该使用1)作为空的函数体，这是不能省略的；
(2)主要考查考生对于指针调用的掌握，根据函数体中对于s1的使用可以看出，它是一个指针类型的变量，调用时实参应该使用“*”，形参使用“&”；
(3)主要考查this指针的使用，this是指向当前对象的指针，应该使用“-＞”访问成员。 -
第16题：
使用VC6打开考生文件夹下的工程test4_1，此工程包含一个源程序文件test4_1.cpp，但该程序在类的定义中存在问题，请改正类定义中的错误，使程序的输出结果如下：
a=3 b=13
a=5 b=13
注意：请勿修改主函数main中的任何内容。
源程序文件rcst4_1.cpp清单如下：
include＜iostream.h＞
class T
{
public:
／*********found***+******／
T(int x){a=x; b+=x;)
／+********found**********／
void display(T c)
{ cout＜＜"a="＜＜c.a＜＜"\t"＜＜"b="＜＜c.b＜＜endl;)
private：
const int a;
static int b;
};
／**********found*********／
int b=5;
void main()
{
T A(3)，B(5);
T::display(A);
T::display(B);
}
正确答案：(1)错误：T(int x){a=x;b+=x;) 正确：T(int x):a(x){b+=x;) (2)错误：void display(T c) 正确：static void display(T c) (3)错误：int b=5; 正确：int T::b=5;
(1)错误：T(int x){a=x;b+=x;) 正确：T(int x):a(x){b+=x;) (2)错误：void display(T c) 正确：static void display(T c) (3)错误：int b=5; 正确：int T::b=5; 解析：(1)主要考查考生对常量数据成员初始化方法的掌握，常量数据成员的初始化只能通过构造函数的成员初始化列表进行，常量数据成员使用关键字const修饰；
(2)主要考查考生对静态成员函数的理解，由主函数中的T::display(A)与T::display(B)可知display应定义为静态成员函数，因为调用类的静态成员必须使用作用域“::”符号；
(3)主要考查考生对静态数据成员初始化方法的掌握，由static int b可知b为静态成员数据，其初始化必须在类外使用作用域运算符(::)限定它所属的类。 -
第17题：
使用VC6打开考生文件夹下的工程test26_1，此工程包含一个源程序文件test26_1.cpp，但该程序运行有问题，请改正
函数中的错误，使该程序的输出结果为：
Values are: 1，2 and 3
源程序文件test26_1.cpp清单如下；
include ＜iostream.h＞
class CommonBase
{
public:
int x;
};
/*****************found*****************/
class DeriveCommonA::public CommonBase
{
public:
int y;
};
class DeriveCommonB:public CommonBase
{
public:
int z;
};
/*****************found*****************/
class Overlapping:public DeriveCommonA; public DeriveCommonB
{
public:
void Display()
{
cout＜＜"Values are: "＜＜DeriveCommonA::x＜＜", "＜＜y＜＜" and "＜＜z＜＜end1;
}
};
int main ( )
{
Overlapping ov;
/*****************found*****************/
ov.x=1;
ov.y=2;
ov.z=3;
ov.Display();
return 0;
}
正确答案：(1)错误：class DeriveCommonA::public CommonBase 正确：class DeriveCommonA:public CommonBase (2)错误：class Overlapping:public DeriveCommonA；public DeriveCommonB 正确：class Overlapping:public DeriveCommonApublic DeriveCommonB (3)错误：ov.x=1; 正确：ov.DeriveCommonA::x=1；
(1)错误：class DeriveCommonA::public CommonBase 正确：class DeriveCommonA:public CommonBase (2)错误：class Overlapping:public DeriveCommonA；public DeriveCommonB 正确：class Overlapping:public DeriveCommonA，public DeriveCommonB (3)错误：ov.x=1; 正确：ov.DeriveCommonA::x=1； 解析：(1)主要考查考生对于派生类定义的理解，C++规定的继承格式是在类名的后面加冒号，之后是继承方式和继承类的名称，题目中错误的使用了作用域运算符;
(2)主要考查考生是否掌握了多继承的定义，多继承的格式基本上和单继承相同，不过在多个基类之间应该使用逗号分开，题目中错误的使用了分号，分号在C++中是结束标志；
(3)主要考查考生对于派生类的对象访问的掌握，x是类CommonBase的成员，如果不加限制的访问就会产生二义性,编译程序不知道这个x是A类的，还是B类的，所以必须使用作用域限制符“::”，为了解决这个问题可以使用虚基类。 -
第18题：
使用VC6打开考生文件夹下的工程test2_1，此工程包含一个源程序文件test2_1.cpp，但该程序运行有问题，请改正程序中的错误，使该程序的输出结果如下：
调用基类BASE的构造函数：1
调用基类BASE的构造函数：2
调用派生类A的构造函数：3
调用派生类A的析构函数
调用基类BASE的析构函数
调用基类BASE的析构函数
源程序文什test2_1.cpp清单如下：
include＜iostream.h＞
class BASE
{
public:
BASE(int i){cout＜＜"调用基类BASE的构造函数:"＜＜i＜＜endl;}
～BASE(){cout＜＜"调用基类BASE的析构函数"＜＜endl;)
／***************** found *****************／
}
class A:public BASE
{
public:
／***************** found *****************／
A(int a,int b):i(a),b(b)
{cout＜＜"调用派生类A的构造函数:"＜＜a+b＜＜endl;}
～A(){cout＜＜"调用派生类A的析构函数"＜＜endl;)
private:
BASE b;
};
void main()
{
／****************found***************／
BASE obj(1,2);
}
正确答案：(1)错误：类BASE的定义缺少“;” 正确：}; (2)错误：A(int aint b)：i(a)b(b) 正确：A(intaintb)：BASE(a)b(b) (3)错误：BASE obj(12); 正确：A obj(12);
(1)错误：类BASE的定义缺少“;” 正确：}; (2)错误：A(int a,int b)：i(a),b(b) 正确：A(inta,intb)：BASE(a),b(b) (3)错误：BASE obj(1,2); 正确：A obj(1,2); 解析：(1)主要考查考生对于类的定义的掌握，类定义结束后大括号外面不能缺少分号；
(2)主要考查考生对于派生类构造函数的掌握，该函数应该实现将参数传递给基类的功能，即派生类的构造函数应使用参数列表的形式将基类的数据成员初始化，初始化的时候直接使用基类的名称(BASE)而不是基类中变量的名称(i)；
(3)主要考查考生对于基类和派生类函数调用关系的掌握，要调用派生类的构造函数必须使用派生类的对象，构造函数只有在该类的对象被使用的时候才会被调用。 -
第19题：
使用VC6打开考生文件夹下的工程proj2。此工程包含一个源程序文件main2.cpp，但该程序运行有问题。请改正main函数中的错误。
源程序文件main2.cpp清单如下：
//main2.cpp
include ＜iostream＞
using namespace std;
class MyClass
{
public:
MyClass(int m)
{
member=m;
}
～MyClass() {}
int GetMember()
{
return member;
}
private:
int member;
};
MyClass MakeObject(int m)
{
MyClass *pMyClass=new MyClass(m);
return *pMyClass;
}
int main ( )
{
int x=7;
/************found**************/
MyClass *myObj=MakeObject(x);
/*************found*************/
cout＜＜"My object has member"＜＜myObj.GetMember()＜＜end1;
return 0;
}
正确答案：修改后的主函数为： int main() { int x=7； MyClass *myObj=&MakeObject(x); cout"My object has member"myObj-＞GetMember()end1; return 0； }
修改后的主函数为： int main() { int x=7； MyClass *myObj=&MakeObject(x); cout"My object has member"myObj-＞GetMember()end1; return 0； } 解析：本题考核对象指针的应用。程序中出现了2个出错标识符，说明此程序有2处错误。
第1处错误：“MyClass*myObj=MakeObject(x)；”。myObj是对象指针，而函数 MakeObject( )的返回值是类MyClass的对象，所以应改为：“MyClass *myObj=&MakeObject(x);”。
第2处错误：“cout"MyObject has member"myObj.GetMember()end1；”。对象指针使用方式有两种：“对象指针名-＞成员名；”和“(*对象指针名)成员名；”。显然上述语句的对象指针的使用方式是错误的。应改为“cout"My object has member"myObj-＞GetMember()end1；”，或者“cout"MyObject has member"(*myObj).GetMember()end1；”。 -
第20题：
使用VC6打开考生文件夹下的工程test19_1，此工程包含一个源程序文件test19_1.cpp，但该程序运行有问题，请改正程序中的错误，使程序的输出结果如下：
1:
weight:5
age:0
2:
weight:7
age:9
源程序文件test19_1.cpp 清单如下:
include ＜iostream.h＞
class animal
{
public:
/**************** found *******************/
friend void setvalue(animal&,int);
/**************** found *******************/
void print()
protected:
int itsweight;
int itsage;
}；
void animal::print()
{
cout＜＜"weight:"＜＜itsweight＜＜end1;
cout＜＜"age:"＜＜itsage＜＜end1;
}
void setvalue(animal &ta,int tw)
{
ta.itsweight=tw;
ta.ihsage=0;
}
void setvalue(animal &ta,int tw, int tn)
{
ta.itsweight=tw;
ta.itsage=tn;
}
void main()
{
/**************** found *******************/
animal peppy
setvalue(peppy,5);
cout＜＜"1:"＜＜end1;
peppy.print();
setvalue(peppy,7,9);
cout＜＜"2:"＜＜end1;
peppy.print();
}
正确答案：(1)错误：缺少友元函数的声明 正确：添加友元函数的声明friend void setvalue(animal &intint)； (2)错误：viod print()； 正确：void print()； (3)错误：animal peppy 正确：animal peppy；
(1)错误：缺少友元函数的声明 正确：添加友元函数的声明friend void setvalue(animal &,int,int)； (2)错误：viod print()； 正确：void print()； (3)错误：animal peppy 正确：animal peppy； 解析：(1)主要考查考生对于成员函数定义规则的掌握，成员函数必须先声明再使用，即使是友元函数也不例外；
(2)主要考查考生对于关键字的掌握，空类型的关键字应用"void"；
(3)主要考查考生对于变量定义的掌握，该处缺少“；”。 -
第21题：
使用VC6打开考生文件夹下的工程test3_1，此工程包含一个源程序文件test3_1.cpp，但该程序运行有问题，请改正程序中的错误，使程序的输出结果如下：
A:a=5
display1:a=6
display2:a=5
源程序文件test3_1.cpp清单如下：
include＜iostream.h＞
Class A
{
public:
／**********found**********／
A (){}
void printa(){cout＜＜"A:a="＜＜a＜＜endl;}
private：
int a;
／***********found**********／
class B;
};
class B
{
public:
／*********found**********／
void display1(A t)
{
(*t).a++；cout＜＜"display1:a="＜＜(*t).a＜＜endl；
}
void display2(A t)
{
t.a--;cout＜＜"display2:a="＜＜t.a＜＜end1;
}
};
void main()
{
A obj1;
B obj2;
obj1.printa();
obj2.display1(&obj1);
obj2.display2(obi1);
}
正确答案：(1)错误：A(){} 正确：A(){a=5；} (2)错误：class B； 正确：friend class B； (3)错误：void display1(At) 正确：void display1(A*t)
(1)错误：A(){} 正确：A(){a=5；} (2)错误：class B； 正确：friend class B； (3)错误：void display1(At) 正确：void display1(A*t) 解析：(1)主要考查考生对于缺省构造函数的理解，由主函数的obj1.printa()可知原缺省构造函数定义不完整；
(2)主要考查考生对于友元的理解，如果类B不是类A的友元，则类B不能直接调用类A的私有成员，只有友元类和友元函数可以访问类的所有成员；
(3)主要考查考生对于指针的概念掌握，由函数体中的使用可以看出，这里的定义应该是对象指针，指针的定义是使用*加上变量名。 -
第22题：
使用VC6打开考生文件夹下的工程test27_1，此工程包含一个源程序文件test27_1.cpp，但该程序运行有问题，请改正函数中的错误，使该程序的输出结果为；
100
源程序文件test27_1.cpp清单如下：
include ＜iostream.h＞
template ＜class T＞
class pair
{
T valuel, value2;
public:
pair (T first, T second)
{valuel=first; value2=second;}
/***************** found *****************/
char getmax ();
};
/***************** found *****************/
T pair＜T＞::getmax ()
{
T retval;
/***************** found *****************/
retval = valuel＞value2?? value1 : value2;
return retval;
}
void main ()
{
pair ＜int＞ myobject (100, 75);
cout ＜＜ myobject.getmax()＜＜end1;
}
正确答案：(1)错误：char getmax()； 正确：T getmax()； (2)错误：缺少模板的声明 正确：templateclassT＞ (3)错误：retval＝valuel＞value2??value1：value2； 正确：retval＝valuel＞value2?value1：value2；
(1)错误：char getmax()； 正确：T getmax()； (2)错误：缺少模板的声明 正确：templateclassT＞ (3)错误：retval＝valuel＞value2??value1：value2； 正确：retval＝valuel＞value2?value1：value2； 解析：(1)主要考查考生对于模板使用的理解，该函数属于模板类定义的一部分，对于返回值类型，应该使用模板类名称T，这样编译的时候才‘能被接受：
(2)主要考查考生是否掌握了模板的使用，前面的模板类已经声明完成了，在类的外面定义类的成员函数时仍然需要使用模板的声明，这样在后面的函数定义体中才能使用模板类；
(3)主要考查考生对于“表达式17表达式2：表达式3”语句的掌握，这个语句是一个复合语句，先计算第一个表达式，如果为真则整个式子值为表达式2的值，否则为表达式3的值，题目中错误的使用了两个问号； -
第23题：
使用VC6打开考生文件夹下的工程test35_1，此工程包含一个源程序文件test35_1.cpp，但该程序运行有问题，请改正程序中的错误，使该程序的输出结果为：
400
40
源程序文件test35_1.cpp清单如下：
include ＜iostream.h＞
class Student
{
public:
Student(int xx){x=xx;}
virtual float calcTuition();
/***************** found *****************/
private:
int x;
};
float Student::calcTuition()
{
return float(x'x);
}
/***************** found *****************/
class GraduateStudent::public Student
{
public:
/***************** found *****************/
GraduateStudent(int xx) ::Student(xx){}
virtual float calcTuition();
};
float GraduateStudent::calcTuition()
{
return float(x*2);
}
void main()
{
Student s(20);
GraduateStudent gs(20);
cout＜＜s.calcTuition()＜＜end1;
cout＜＜gs.calcTuition()＜＜end1;
}
正确答案：(1)错误：private： 正确：protected： (2)错误：class GraduateStudent：：public Student 正确：class GraduateStudent：public Student (3)错误：GraduateStudent(int XX)：：Student(xx){} 正确：GraduateStudent(int xx)：Student(xx){}
(1)错误：private： 正确：protected： (2)错误：class GraduateStudent：：public Student 正确：class GraduateStudent：public Student (3)错误：GraduateStudent(int XX)：：Student(xx){} 正确：GraduateStudent(int xx)：Student(xx){} 解析：(1)本题考查点为派生类对基类成员的访问。派生类中的成员不能访问基类中的私有成员，只可以访问基类中的公有成员和保护成员。
(2)派生类的一般格式“class派生类名＞：继承方式1＞基类名1＞，……{派生类新定义成员＞}；”，所以应将“：：”改为规定的“：”，“：：”是作用域运算符，用来标识某个成员属于某个类。
(3)派生类构造函数在类体内定义的一般格式“派生类名＞：基类名1＞(参数表1＞)，……{派生类构造函数体＞}”，所以应将“：：”改为规定的“：”。