面向对象程序设计打印.doc

一、 填空题
1.面向对象系统的四个特性分别是抽象性继承性、 封装性和多态性。
2.如果一个类至少有一个纯虚函数,那么该类被称为抽象类。
3.对于含有对象成员的派生类,其构造函数的执行顺序为: 先执行基类构造函数、 再执行子对象构造函数,最后执行派生类构造函数。
4.纯虚函数的声明格式为: virtual函数类型函数名(参数列表)=0;。
5.运算符重载依然保持原来的结合性、 优先级和语法结构。
6.类型转换函数的作用是将一个类的对象转换成另一类型的数据。
7.静态联编支持的多态性称为编译时的多态性,也称静态多态性。
8.类中成员的三种访问权限分别是public、 private和protected。
9.定义派生类时,系统默认的继承方式是private。
10.C++允许在相同的作用域内以相同的名字定义几个不同实现的函数,称这种同一个函数名多种含义的现象为函数重载。
11.在C++中,运行时的多态性主要经过虚函数和继承实现。
12.在一个函数的定义或声明前加上关键字inline时,该函数就声明为内置函数。
13.派生类的成员包括从基类继承来的成员和自己增加的成员两大部分。
14.cin称为C++标准输入流。 63.在C++语言中,cout被称为 标准输出流 。
15.在C++语言中,用运算符new动态建立对象,用运算符delete撤消对象。
16.基类的 构造函数 和 析构函数 不能被派生类继承。
17.名称为temp的类的复制构造函数的原型声明语句为temp(consttemp&s);。
18.设置友元函数的目的是为了能够访问该类的私有成员和保护成员。
19.在C++程序中,静态成员函数主要用来访问静态数据成员。
20.类模板是类的抽象,类是类模板的实例。
21.拷贝构造函数的形参必须是当前类对象的引用类型。
22.进行函数重载时,被重载的同名函数如果都没有用const修饰,则它们的形参个数不同或类型不同或个数和类型都不同。
23.在类中必须声明成员函数的原型,成员函数的 实现 部分能够写在类外。
24.多态性 是指发出同样的消息被不同类型的对象接收时有可能导致完全不同的行为。
25.在已有类的基础上新增自己的特性而产生新类的过程称为 派生。
26.当用类的一个对象去初始化该类的另一个对象时系统自动调用 复制构造函数 实现赋值。
27.友元函数是在类声明中由关键字friend修饰说明的非成员函数,在它的函数体中能够经过对象名访问private和protected成员。
28.如果需要在某个类的声明之前,引用该类,则应进行 前向引用 声明。
29.对象 是将数据及对数据的操作方法封装在一起,作为一个相互依存、 不可分离的整体。
30.C++中输出数据时,在标准输出流对象cout之后使用的运算符”<<”称为流插入。
31.从系统实现角度看,多态性分为静态多态性和 动态多态性。
32.基类的 私有成员 在派生类中是不可访问的。
33.对象空间的起始地址就是 对象的指针。
34.对象与对象之间经过 消息 进行通讯。
35.C++中用于定义模板的关键字是template。
36.在C++的类中包含两种成员,分别是 数据成员和 成员函数。
37.所谓 函数模版 ,实际上是建立一个通用函数,其函数类型和形参类型不具体指定,用一个虚拟的类型来代表。
38.C++为提高函数调用的效率,允许在编译时将所调用函数的代码嵌入到主函数中,这种嵌入到主函数的函数称为 内置函数 。
39.类中有两种特殊的成员函数,分别是 构造函数 和 析构函数。
40.若要定义指向Time类对象t1的常指针ptr,其定义语句为: Time * const ptr=&t1;。
41.如果函数的形参为类的对象,在调用函数时需要将实参对象完整地传递给形参对象,此时系统要调用 复制构造函数 来实现。
42.如果需要在同类的多个对象之间实现数据共享,但不用全局变量,能够用 静态成员变量。
43.在C++中,要访问类中的私有成员,能够使用 成员函数 和 友元函数。
44.C++中,有四个运算符必须重载为类的成员函数,而不能重载为友元函数,这四个运算符分别是: =,[],(),->。
45.若要实现两个复数类对象相加运算,而且满足交换律,要将”+”重载为类的 友元函数 。
46.面向对象技术强调软件的可重用性,C++语言提供了类的 继承 机制,解决了软件重用问题。
47.C++中允许一个派生类同时继承多个基类,这种行为称为 多重继承。
48.声明虚基类命令的的一般形式为class 派生类名:virtual 继承方式 基类名。
49.只有 公用继承 才是基类真正的子类型。
50.动态多态性是在程序运行过程中才动态地确定操作所针正确对象,又称为 运行时的多态性。
51.虚函数一定是类的 成员函数。
52.静态成员函数 没有this指针。
53.类中成员默认的访问属性是private。
54.用关键字inline声明的函数称为 内置函数。
55.若将两个复数相加运算符”+”重载为类complex的成员函数,且函数的返回值为当前类的对象,其函数的原型声明语句为
complex operator+(complex &);。
56.若用op代表C++中任意一个允许重载的运算符,其重载函数名为operator op。
57.C++中的模板分为 类模板 和 函数模板。
58.具有 封装性、 继承性 和 多态性 特点的程序设计称为面向对象的程序设计。
59.用已有对象复制一个新对象时要调用 复制构造函数 。
60.在基类中将show( 无参数) 声明为返回整型数据的纯虚函数的语句格式为: virtual int show()=0;。
61.在派生类中,对基类的继承方式能够有 public、 private和protected。
62.将双目运算符重载为某类的成员函数时,该成员函数的左操作数为当前对象( 或*this) ,右操作数为 函数参数。
64.若要访问类中的私有成员,除了能够利用成员函数外,还能够采用的 友元函数 的方式。
65.定义静态成员函数的目的是为了访问类中的 静态数据成员 。
66.要实现运行时的多态性要使用 虚函数 和 继承。
67.派生类的成员来自两个途径,一种是派生类中定义的成员,另一种 从基类继承来的成员。
68.构造函数 是一种特殊的成员函数,其作用是对类的数据成员进行初始化并执行对象的其它内部管理操作。
69.在类中定义和实现的函数称为 成员函数。
70.const成员函数 只能引用本类中的数据成员,而不以修改数据成员。
71.如果一个类中至少有一个 纯虚函数 ,那么该类被称为抽象类。
72.C++中用static声明的对象称为静态对象。
73.若有类名为sample,则其复制构造函数的原型声明语句为sample(const sample &);。
二、 选择题
1．设int ×=10,×+=3+×%(-3),则×=______C___。
A.15 B. 11 C. 14 D.12
2．下列运算符,不能重载为友元函数的是_______D________。
A.<、 >、 <=、 >= B.+、 -、 ++、 -- C. +=、 -=、 *=、 /= D. =、 ( ) 、 []、 ->
3．在C++中,要实现动态联编,必须使用______B_______调用虚函数
A. 派生类指针 B.基类指针 C.对象名 D.类名
4．若运算符”>”被重载为类的成员函数,则表示式obj1>obj2被C++编译器解释为____A_____。
A. obj1.operator>(obj2) B. obj2.operator>(obj1)
C. operator>() D. >(obj1,obj2)
5．对于语句cout<<×<<endl;中的各个组成部分,下列叙述中错误的是_____B______。
A.”cout”是一个输出流对象 B. ”<<”称作流提取运算符
C.”×”是一个变量 D. ”endl”的作用是输出回车换行
6．在下列函数原型中,能够作为类AA构造函数的是_____B__________。
A. int AA( ) ; B. AA( int) ; C.AA( int) const; D.void AA( int) ;
7．函数调用语句fun( a+b,3,ma×( n-1,b) ) ;中,实参的个数为_______D______
A. 4 B. 6 C.5 D. 3
8．有关虚函数的说法不正确的是______B_________。
A. 构造函数不能是虚函数 B.静态成员函数能够是虚函数
C.只有类的成员函数才能说明为虚函数 D.析构函数能够是虚函数
9．逗号表示式a=4,b=6,a--,b--,a+b的值为______B_________。
A. 9 B. 8 C.10 D.6
10．对于类中定义的成员,其隐含访问权限为______B________
A. public B. private C. static D. protected
11.设置虚基类的目的是____C_______。
A.简化程序 B. 提高运行效率 C. 消除二义性 D.减少目标代码
12.定义函数模板使用的关键字是_____A______。
A. template B.inline C. class D.operator
13.在int b[][3]={{1},{3,2},{4,5,6},{0}};中b[2][2]的值是___C____。
A.0 B.5 C.6 D.2
14.友元的作用之一是____B______。
A.增加成员函数的种类 B.提高程序的运行效率
C.实现数据的隐藏性 D. 加强类的封装性
15.下列表示引用的方法中,_____C_____是正确的。已知: int m=10;
A. int &z; B.int &y=10; C. int &×=m; D. float &t=&m;
16.经过指向对象的指针变量取成员的运算符是____C_____。
A. >> B. · C. -> D. <<
17.已知类A中一个成员函数说明如下:
Void set(A &a);其中,A &a的含义是_____C____。
A.指向类A的指针为a
B.将a的地址值赋给变量set
C. a是类A的对象引用,用来作为函数set( ) 的形参
D. 变量A与a按位相与作为函数set( ) 的参数
18.带有虚基类的多层派生类构造函数的成员初始化列表中都要列出虚基类的构造函数,这样将对虚基类的子对象初始化次数____B_____。
A.与虚基类下面的派生类个数有关 B.一次 C.二次 D. 多次
19.下列函数中,_____D____不能重载。
A.成员函数 B. 非成员函数 C.构造函数 D.析构函数
20.关于动态联编的下列描述中,____A_____是错误的。
A.动态联编是在编译时确定操作函数的
B. 动态联编是以虚函数为基础的
C. 动态联编是在运行时确定所调用的函数代码的
D.动态联编调用函数操作是用指向对象的指针或对象引用
21.下列运算符中,_____D____运算符不能重载。
A. && B. new C. [] D. ::
22.关于虚函数的描述中,___A______是正确的。
A.函数基类中说明了虚函数后,派生类中将其对应的函数可不必说明为虚函数
B.虚函数是一个非成员函数
C. 虚函数是一个static类型的成员
D.派生类的虚函数与基类的虚函数具有不同的参数个数和类型
23.下面关于对象的描述中,错误的是___D______。
A. 对象之间的信息传递是经过消息进行的 B.对象是类的实例
C.一个类能够定义多个对象 D.对象是类的别名
24.下述静态数据成员的特性中,____C_____是错误的。
A.说明静态数据成员时前边要加修饰符static
B.引用静态数据成员时,要在静态数据成员名前加<类名>和作用域运算符
C.静态数据成员不是所有对象所共用的
D.静态数据成员要在类体外进行初始化
25.有关类的说法中,不正确的是____D_____。
A.类是一种用户定义的数据类型
B.类中的成员函数能够存取类中的私有数据
C.在类中,如果不作特别说明,所有的成员函数均为私有类型
D.在类中,如果不作特别说明,所有的数据成员均为公有类型
26.当一个派生类私有继承一个基类时,基类中的所有公有成员和保护成员成为派生类的__C_。
A. public成员 B. protected成员 C. private成员 D.友元
27.有如下类声明: class sample {public:int mem;};
则sample类的成员mem是____B_____
A．公有成员函数 B．公有数据成员 C．私有数据成员 D．私有成员函数
28.在C++中,关于设置参数的默认值的描述中,正确的是____A____。
A.设置参数默认值时,应该是先设置右边的再设置左边的
B.设置参数默认值只能在定义函数时设置
C.设置参数默认值时,应该全部参数都设置
D.不允许设置参数的默认值
29.函数模板的使用,实际上是将函数模板实例化成一个具体的____B____。
A.类 B.函数 C.对象 D.模板类
30.在多重继承中,公有派生和私有派生对于基类成员在派生类中的可访问性与单继承的规则____A____。
A.完全相同 B.完全不同 C.部分相同,部分不同 D.以上都不对
31.下面关于对象概念的描述中,____C____是错误的。
A.对象是一个状态和操作(或方法)的封装体
B.对象代表着正在创立的系统中的一个实体
C.对象就是C语言中的结构体变量
D.对象之间的信息传递是经过消息进行的
32.继承机制的作用是_____A_____
A．定义新类 B．数据封装 C．数据抽象 D．信息隐藏
33.有关析构函数的说法不正确的是____A_____
A.析构函数不能是虚函数 B.析构函数无任何函数类型
C.析构函数没有形参 D.析构函数有且只有一个
34.友元的作用之一是____C______
A.加强类的封装性 B.实现数据的隐藏性
C.提高程序的运行效率 D.增加成员函数的种类
35.一般拷贝构造函数的参数是____B______。
A.本类对象名 B.本类对象的引用名 C.本类对象的成员名 D.本类对象的指针名
36.如果在基类中将show声明为不带返回值的纯虚函数,正确的写法是_____C___。
A.virtual show()=0; B.virtual void show() ;
C.virtual void show()=0; D.void show=0 virtual;
37.下面关于友元的描述中,错误的是___A______。
A.类与类之间的友元关系能够继承
B.一个类的友元类中的成员函数都是这个类的友元函数
C.友元函数能够访问该类的私有数据成员
D.友元能够提高程序的运行效率
38.在C++中,_____B____运算符不能重载。
A. + B. sizeof C.- D.<=
39.下列关于运算符重载的描述中,____A____是正确的。
A.运算符重载不能够改变语法结构 B.运算符重载能够改变结合性
C.运算符重载能够改变优先级 D.运算符重载能够改变操作数的个数
40.当一个派生类保护继承一个基类时,基类中的所有公有成员和保护成员成为派生类的__B_。
A.private成员 B. protected成员 C. public成员 D.友元
41.在声明类时,下面的说法正确的是____B____。
A.能够在类的声明中给数据成员赋初值
B.private,public,protected能够按任意顺序出现
C.数据成员的数据类型能够是register
D.没有用private,public,protected定义的数据成员是公有成员
42.有如下类声明: class Foo {int bar ;};
则Foo类的成员bar是____A_____
A．私有数据成员 B．私有成员函数 C．公有数据成员 D．公有成员函数
43.设置虚基类的目的是____B____。
A.简化程序 B. 消除二义性 C.减少目标代码 D. 提高运行效率
44.对虚函数的调用_____A_____。
A.不一定使用动态联编 B.必须使用动态联编
C.一定使用动态联编 D.一定使用静态联编
45.关于成员函数特征的下述描述中,____B___是错误的。
A.成员函数能够是静态的 B.成员函数一定是内置函数
C.成员函数能够设置参数的默认值 D.成员函数能够重载
46．类的成员函数不包括_______C________。
A．构造函数 B.析构函数 C.友元函数 D.拷贝构造函数
47.继承具有___A_____,即当基类本身也是某一个类的派生类时,底层的派生类也会自动继承间接基类的成员。
A.传递性 B.规律性 C.重复性 D.多样性
48．若运算符”>”被重载为类的友元函数,则表示式obj1>obj2被C++编译器解释为___C____。
A. >(obj1,obj2) B. obj1.operator>(obj2)
C. operator>(obj1,obj2) D. operator>()
49．下面关于友元的描述中,错误的是___C______。
A.友元函数能够访问该类的私有数据成员
B.友元能够提高程序的运行效率
C.类与类之间的友元关系能够继承
D.一个类的友元类中的成员函数都是这个类的友元函数
50．有关构造函数的说法不正确的是____C_____。
A.构造函数名字和类的名字一样 B.构造函数无任何函数类型
C.构造函数有且只有一个 D.构造函数在说明类的某个对象时自动执行
51．设n=8,i=4,则赋值运算n%=i+1执行后,n的值是_____C_____。
A. 0 B. 1 C. 3 D. 2
52．在下列选项中,_____B____不能作为判定函数重载的依据。
A.参数个数 B.函数的类型 C. 参数的类型 D.函数名称
53．有关虚函数的说法不正确的是______A_________。
A.静态成员函数能够是虚函数 B.只有类的成员函数才能说明为虚函数
C.构造函数不能是虚函数 D.析构函数能够是虚函数
54.派生类的对象对它的基类___D___是能够访问的。
A.公有继承的私有成员 B.私有继承的公有成员
C.公有继承的保护成员 D.公有继承的公有成员
55.下列关于switch语句的描述中,___A__是正确的。
A. switch语句中default子句能够没有,也可有一个
B. switch语句中每个语句序列中必须有break语句
C. switch语句中default子句只能放在最后
D. switch语句中case子句后面的表示式只能是整型表示式
56．能用友元函数重载的运算符是____D______。
A. -> B. = C. [] D. +

三、 读程序写结果
1.#include <iostream.h>
using namespace std;
class point
{public:
point(int i,int j){x=i;y=j;}
void print(){cout<< ‘(’<<x<< ‘,’<<y<<‘)’<<endl;}
void operator+=(point p){x+=p.x;y+=p.y;}
void operator-=(point p){x-=p.x;y-=p.y;}
private:
int x,y;
};
void main()
{point p1(2,3),p2(1,4);
p1.print();
p2.print();
p1+=p2;
p1.print();
p2-=p1;
p2.print();
}
运行结果:
(2,3)
(1,4)
(3,7)
(-2,-3)
2.
#include<iostream.h>
using namespace std;
class timer
{public:
timer() {seconds=0;}
timer(int t) {seconds=t;}
timer(int min,int sec) {seconds=min*60+sec;}
int gettime() {return seconds;}
private:
int seconds;
};
void main()
{timer a,b(20),c(3,12);
cout<<"seconds1="<<a.gettime()<<endl;
cout<<"seconds2="<<b.gettime()<<endl;
cout<<"seconds3="<<c.gettime()<<endl;
}
运行结果:
seconds1=0
seconds1=20
seconds1=192

3．
#include <iostream>
using namespace std;
class A
{public:
A(int i,int j){a=i;b=j;}
void move(int x,int y){a+=x;b+=y;}
void show(){cout<< '('<<a<< ','<<b<<')'<<endl;}
private:
int a,b;
};
class B:public A
{public:
B(int i,int j,int k,int l):A(i,j),x(k),y(l){}
void show(){cout<<x<<","<<y<<endl;}
void fun(){move(3,5);}
void f1(){A::show();}
private:
int x,y;
};
int main()
{A e(4,6);
e.show();
B d(1,3,2,5);
d.fun();
d.A::show();
d.B::show();
d.f1();
system("pause");
return 0;
}
运行结果:
(4,6)
(4,8)
2,5
(4,8)

4.
#include <iostream>
using namespace std;
class A
{public:
A(int i=0){m=i;cout<<"constructor called."<<m<<endl;}
void set(int i) {m=i;}
void print() const {cout<<m<< endl;}
A(const A &s){m=s.m;cout<<"copy"<<endl;}
~A(){cout<<"destructor called."<<m<<endl;}
private:
int m;
};
int main()
{const int N=7;
A my;
my=N;
my.print();
return 0;
}

运行结果:
constructor called.0
constructor called.7
desstructor called.7
7
desstructor called.7
5.
#include<iostream>
using namespace std;
class M
{public:
M(int a=0,int b=0) {x=a;y=b;}
int getx() {return x;}
int gety() {return y;}
private:
int x,y;
};
int main()
{ M op1(8,6);
int i,j;
i=op1.getx();
j=op1.gety();
cout<<"i="<<i<<",j="<<j<<endl;
system("pause");
return 0;}
运行结果:
i=8,j=6
6. #include <iostream>
using namespace std;
template<class type1,class type2>
void myfunc(type1 x,type2 y)
{cout<<x<<','<<y<<endl;}
int main()
{myfunc(27,"program");
myfunc(12.23,32u);
return 0;}
运行结果:
27, "program"
12.23,32

7.
#include <iostream>
#include <iomanip>
using namespace std;
class Book
{int num,price;
public:
Book(int a=0,int b=0){num=a;price=b;}
void showMoney(){cout<<setw(4)<<num*price<<endl;}
};
int main()
{ Book b[]={Book(3,9),Book(2,8),Book(4,7)};
Book *p;int i;
p=b;
for(i=0;i<3;i++,p++)
p->showMoney();
system("pause");
return 0;}
运行结果:
27 (前面有俩空格)
16 (前面有俩空格)
28 (前面有俩空格)
8.#include<iostream>
using namespace std;
class Point
{ public:
Point()
{ X=Y=0; cout<<"FIRST:Default Constructor called.\n";}
Point(int xx,int yy)
{ X=xx; Y=yy; cout<< "SECOND:Constructor called.\n"; }
~Point() { cout<<"THIRD:Destructor called.\n"; }
int GetX() {return X;}
int GetY() {return Y;}
void Move(int x,int y) { X=x; Y=y; }
private:
int X,Y;
};
int main()
{ cout<<"Step One:"<<endl;
Point *Ptr1=new Point;
delete Ptr1;
cout<<"Step Two:"<<endl;
Ptr1=new Point(5,6);
delete Ptr1;
return 0;}
运行结果:
Step One:
FIRST:Default Constructor called.
THIRD:Destructor called.
Step Two:
SECOND:Constructor called.
THIRD:Destructor called.
9．
#include <iostream.h>
class Point
{ public:
Point(int xx,int yy);
~Point();
int GetX() {return X;}
int GetY() {return Y;}
private:
int X,Y;
};

Point::Point(int xx,int yy)
{ X=xx; Y=yy;cout<< "Constructor called."<<endl;}
Point ::~Point()
{ cout<<"Destructor called."<<endl; }
int main()
{ Point A(1,4);
Point *ptr;
ptr=&A;
int x;
x=ptr->GetX();
cout<<x<<endl;
return 0;
}
运行结果:
Constructor called.
1
Destructor called.

10.
#include<iostream>
using namespace std;
class Test
{static int count;
public:
Test(){++count;cout<<"对象数量="<<count<<endl; }
～Test(){--count;cout<<"对象数量="<<count<<endl; }
};
int Test::count=0;
int main()
{Test t[4];}
运行结果:
对象数量=1
对象数量=2
对象数量=3
对象数量=4
对象数量=3
对象数量=2
对象数量=1
对象数量=0
11.
#include <iostream>
using namespace std;
int main()
{ int num=2345;long p=1;
do
{p*=num%10;
num/=10;}while(num);
cout<<"p="<<p<<endl;
return 0;
}
运行结果:
p=120
12.
#include<iostream>
using namespace std;
int a[]={1,2,3,4,5};
int & fun(int i)
{return a[i];}
int main()
{ int i;
fun(2)=10;
for(i=0;i<5;i++)
cout<<a[i]<<” ”;//” ”中间空2个格
cout<<endl;
system("pause");
return 0;}
运行结果:
1 2 10 4 5 (中间两个空格)
13.
#include <iostream>
using namespace std;
int n=0;
int &f(int m)
{ n+=m;return n;}
int main()
{ f(3)+=21;
cout<<"n="<<n<<endl;
return 0;}
运行结果:
n=24
14．
#include <iostream>
#include <iomanip>
using namespace std;
class myclass
{public:
myclass(){cout<<setw(4)<<1;}
myclass(char c){cout<<setw(4)<<2;}
～myclass(){cout<<setw(4)<<3<<endl;}
};
int main()
{myclass a,p1,*p2;
p2=new myclass('X');
delete p2;
system("pause");
return 0;}
运行结果:
1 1 2 3 (每个数字前面3个空格)
3 (每个数字前面3个空格)
3 (每个数字前面3个空格)
15. #include <iostream>
using namespace std;
int &f1(int n,int s[])
{int &m=s[n];
return m;}
int main()
{int s[]={1,2,3,4,5,6};
f1(2,s)=10;
cout<<f1(2,s)<<endl;
return 0;}
运行结果:
10

16.
#include <iostream>
using namespace std;
class B;
class A
{public:
A(int i){a=i;}
friend int F(A &f1,B &f2);
private:
int a;
};
class B
{public:
B(int i){b=i;}
friend int F(A &f1,B &f2);
private:
int b;
};
int F(A &f1,B &f2)
{return (f1.a+f2.b)*(f1.a-f2.b);}
int main()
{A n1(8);
B n2(6);
cout<<F(n1,n2)<<endl;
return 0;
}
运行结果:
28

四、 程序填空
1.下面的程序中定义抽象类Base1,利用基类指针作函数形参调用虚函数,以实现动态联编。
#include <iostream>
using namespace std;
class Base1//(1)基类Base1定义
{public:
virtual void display() const=0;//(2)纯虚函数( 常成员函数) 的定义
};
class Base2:public Base1//(3)基类Base1的公有派生类Base2定义
{public:
void display() const;
};
void Base2::display() const
{cout << "Base2::display()" << endl;}
class Derived:public Base2//(4)派生类Derived公有继承Base2
{public:
void display() const;
};
void Derived::display() const
{cout << "Derived::display()" << endl;}
void fun(Base1 *ptr)//(5)形参为基类指针的没有返回值的普通函数fun的函数首部
{ptr->display();//(6)用基类指针ptr调用虚函数display()
}
int main()
{Base2 base2;
Derived derived;//(7)定义Derived类对象
fun(&base2);//(8)用Base2对象的指针调用fun函数
fun(&derived);
return 0;
}

2.下面的程序是应用普通函数作为类的友元函数,以访问类中的私有成员。
#include <iostream>
using