作业6-多态

以后做完题一定要及时总结到博客里……不要拖着orz

而且我觉得作业都留的太巧妙了，不写作业掌握的都是假知识

1.看上去是多态

 1 //程序填空产生指定输出
 2 /*
 3 输出
 4 D::Fun
 5 B::Fun
 6 D::Fun
 7 nBVal=2
 8 nBVal=24
 9 nDVal=8
10 B::Fun
11 nBVal=12
12 */ 
13 #include <iostream>
14 using namespace std;
15 class B { 
16     private: 
17         int nBVal; 
18     public: 
19         void Print() 
20         { cout << "nBVal="<< nBVal << endl; } 
21         void Fun() 
22         {cout << "B::Fun" << endl; } 
23         B ( int n ) { nBVal = n;} 
24 };
25 // 在此处补充你的代码
26 class D:public B{ 
27     int nDVal;
28     public: 
29         void Print() 
30         {     
31             B::Print(); //覆盖，调用基类函数时要加B:: 
32             cout << "nDVal="<< nDVal << endl; 
33         } 
34         void Fun() 
35         {cout << "D::Fun" << endl; } 
36         D ( int n ):nDVal(n),B(3*n){} 
37 };
38 int main() { 
39     B * pb; D * pd; 
40     D d(4); d.Fun(); 
41     pb = new B(2); pd = new D(8); 
42     pb -> Fun(); pd->Fun(); 
43     pb->Print (); pd->Print (); //默认调用的是D中的Print 
44     pb = & d; pb->Fun(); //为啥调用的是B的函数？ 通过指针调用成员函数，只跟指针类型有关系
45     pb->Print(); 
46     return 0;
47 }

备注：这道题叫看上去是多态实际上就不是多态。对于不是多态的情况，如果派生类和基类里有同名函数，就是覆盖关系，这是第五讲的内容，结果我都忘了……如果是派生类默认调用的是派生类的成员函数。对于非多态来说，通过指针调用成员函数，只跟指针类型有关系，也就是说指针类型决定了调用的是基类还是派生类的成员函数。我猜这道题的含义是，老师为了让我们体会多态的意义。因为不用多态，就不能实现用基类指针调用派生类的虚函数。

2.Fun和Do

 1 /*A::Fun
 2 C::Do*/ 
 3 #include <iostream> 
 4 using namespace std;
 5 class A { 
 6     private: 
 7     int nVal; 
 8     public: 
 9     void Fun() 
10     { cout << "A::Fun" << endl; }; 
11     void Do() 
12     { cout << "A::Do" << endl; } 
13 }; 
14 class B:public A { 
15     public: 
16     virtual void Do() 
17     { cout << "B::Do" << endl;} 
18 }; 
19 class C:public B { 
20     public: 
21     void Do( ) 
22     { cout <<"C::Do"<<endl; } 
23     void Fun() 
24     { cout << "C::Fun" << endl; } 
25 }; 
26 /*函数的参数传入的是B &p,
27 Fun函数没有多态，执行的是A（B中没有Fun这个函数，所以调用的是基类中的Fun，Do函数多态，执行的是C::Do*/
28 void Call(//输入代码 派生类对象可以赋值给基类引用，然后看看是函数不是多态 
29  B &p
30  ) { 
31     p.Fun(); p.Do(); 
32 } 
33 int main() { 
34     C c; 
35     Call( c); 
36     return 0;
37 }

备注：这道题就让填一个参数。这是多态的第二种应用，就是派生类对象可以赋值给基类引用。这道题里Call的实参就是一个B类对象，对于Fun函数来说，Fun不是多态，并且B中没有Fun函数，所以调用的就是A中的；对于虚函数Do来说，p.Do()就是多态,这时发现p是一个C类对象，所以调用的是C类的Do函数。

3.这是什么鬼delete

 1 /*
 2 destructor B
 3 destructor A
 4 */ 
 5 #include <iostream> 
 6 using namespace std;
 7 class A 
 8 { 
 9 public:
10     A() { }
11 // 在此处补充你的代码
12     virtual ~A(){ cout << "destructor A" << endl; } 
13 }; 
14 class B:public A { 
15     public: 
16     ~B() { cout << "destructor B" << endl; } 
17 }; 
18 //我们知道一般析构顺序是派生类到基类，但是如果是基类的指针指向派生类，
19 //如果基类的析构函数不设置为虚函数，那么就程序就只会调用基类的析构函数，不会调用派生类的析构函数
20 //考察虚析构函数，一个类作为基类，析构函数应该设为虚函数 
21 int main() 
22 { 
23     A * pa; 
24     pa = new B; 
25     delete pa; 
26     return 0;
27 }

备注：

这道题就是考察虚析构函数，一个类作为基类，析构函数应该设为虚函数。

4.怎么又是Fun和Do

扫描二维码关注公众号，回复： 10060145 查看本文章

 1 /*
 2 A::Fun
 3 A::Do
 4 A::Fun
 5 C::Do
 6 */ 
 7 #include <iostream>
 8 using namespace std;
 9 class A {
10     private:
11     int nVal;
12     public:
13     void Fun()
14     { cout << "A::Fun" << endl; };
15     virtual void Do()
16     { cout << "A::Do" << endl; }
17 };
18 class B:public A {
19     public:
20     virtual void Do()
21     { cout << "B::Do" << endl;}
22 };
23 class C:public B {
24     public:
25     void Do( )
26     { cout <<"C::Do"<<endl; }
27     void Fun()
28     { cout << "C::Fun" << endl; }
29 };
30 void Call(
31 // 在此处补充你的代码
32 A*p
33 ) {
34     p->Fun(); p->Do();
35 }
36 int main() {
37     Call( new A());
38     Call( new C());
39     return 0;
40 }

猜你喜欢