} };
int main( ) { Base b1(1); //定义基类对象b1 cout << \基类对象 b1.show( ):\\n\ b1.show( ); Derived d1(2); //定义派生类对象d1 b1=d1; //用派生类对象给基类对象赋值 cout << \基类b1=d1, b1.show( ):\\n\ b1.show( ); cout << \派生类对象 d1.show( ):\\n\ d1.show( ); Base & b2=d1; //用派生类对象来初始化基类引用 cout << \引用b2=d1, b2.show( ):\\n\ b2.show( ); Base * b3=&d1; //派生类对象的地址赋给指向基类的指针 cout << \基类指针b3=&d1, b3->show( ):\\n\ b3->show( ); Derived *d4=new Derived(3); //定义派生类指针并生成新对象 Base *b4 = d4 ; //派生类指针赋给指向基类的指针 cout << \基类指针b4 = d4, b4->show( ):\\n\ b4->show( );
cout << \派生类指针d4, d4->show( ):\\n\ d4->show( ); delete d4; return 0; }
运行结果：
基类对象 b1.show( ): i in Base is: 1
基类b1=d1, b1.show( ): i in Base is: 2
派生类对象 d1.show( ): i in Derived is: 2
引用b2=d1, b2.show( ): i in Base is: 2
基类指针b3=&d1, b3->show( ): i in Base is: 2
基类指针b4 = d4, b4->show( ): i in Base is: 3
派生类指针d4, d4->show( ): i in Derived is: 3
Press any key to continue
① 对赋值兼容的4种情况作测试，对每行的输出结果进行观察，理解赋值兼容何时
调用基类的成员函数，什么情况下才会调用派生类的成员函数。 答：4种情况：
基类对象 = 公有派生类对象 b1=d1;
b1.show( );调用的是基类Base的成员函数show； 指向基类对象的指针 = 公有派生类对象的地址 Base * b3=&d1;
b3->show( ); 调用的是基类Base的成员函数show； 指向基类对象的指针 = 指向公有派生类对象的指针 Base *b4 = d4 ;
b4->show( ); 调用的是基类Base的成员函数show；
基类的引用 = 公有派生类对象，即派生类对象可以初始化基类的引用。 Base & b2=d1;
b2.show( ); 调用的是基类Base的成员函数show；
由此可知，只要是基类的对象或对象指针（引用）均调用的是基类的函数；只有在调用函数的对象或指针是派生类的时候才会调用派生类的成员函数。如d1.show( ); d4->show( ); 均调用的是派生类的成员函数。
② 在主函数的return 0;语句前增加4条语句，观察并记下编译时的报错信息，理解赋
值兼容的不可逆性。
//增加4条语句，理解赋值兼容规则的不可逆性 Derived d5 = b1;
该语句编译不能通过，因为不能用基类对象对派生类对象初始化 Derived &d6 = b1;
该语句编译不能通过，因为派生类对象不能用来作为基类对象的别名 Derived *d7 = &b1;
该语句编译不能通过，因为派生类对象指针不能指向基类对象 d7 = b3;
该语句编译不能通过，因为派生类对象指针不能被赋值为基类对象指针 题目2指导：
① //赋值兼容原则
#include
int i;
Base(int x): i(x) { { }
cout << \ } void show( ) public:
};
class Derived: public Base { public: }; int main( ) { }
Base （1） cout << \基类对象 b1.show( ):\\n\ b1.show( );
Derived （2） （3） cout << \基类b1=d1, b1.show( ):\\n\ b1.show( );
cout << \派生类对象 d1.show( ):\\n\ d1.show( );
Base （4） cout << \引用b2=d1, b2.show( ):\\n\ b2.show( );
Base （5） b3->show( );
Derived *d4 = （6） Base *b4 = d4 ; cout << \基类指针b4 = d4, b4->show( ):\\n\b4->show( );
cout << \派生类指针d4, d4->show( ):\\n\d4->show( ); delete d4; return 0;
//定义派生类指针并生成新对象 //派生类指针赋给指向基类的指针 //派生类对象的地址赋给指向基类的指针
cout << \基类指针b3=&d1, b3->show( ):\\n\
//用派生类对象来初始化基类引用
//定义派生类对象d1
//用派生类对象给基类对象赋值
//定义基类对象b1
Derived(int x): Base(x) { } void show( ) { }
cout << \
② //增加4条语句，理解赋值兼容规则的不可逆性
Derived d5 = b1; Derived &d6 = b1; Derived *d7 = &b1; d7 = b3;