作业6-多态

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

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

1.看上去是多态

//程序填空产生指定输出
/*
输出
D::Fun
B::Fun
D::Fun
nBVal=2
nBVal=24
nDVal=8
B::Fun
nBVal=12
*/ 
#include <iostream>
using namespace std;
class B { 
    private: 
        int nBVal; 
    public: 
        void Print() 
        { cout << "nBVal="<< nBVal << endl; } 
        void Fun() 
        {cout << "B::Fun" << endl; } 
        B ( int n ) { nBVal = n;} 
};
// 在此处补充你的代码
class D:public B{ 
    int nDVal;
    public: 
        void Print() 
        {     
            B::Print(); //覆盖，调用基类函数时要加B:: 
            cout << "nDVal="<< nDVal << endl; 
        } 
        void Fun() 
        {cout << "D::Fun" << endl; } 
        D ( int n ):nDVal(n),B(3*n){} 
};
int main() { 
    B * pb; D * pd; 
    D d(4); d.Fun(); 
    pb = new B(2); pd = new D(8); 
    pb -> Fun(); pd->Fun(); 
    pb->Print (); pd->Print (); //默认调用的是D中的Print 
    pb = & d; pb->Fun(); //为啥调用的是B的函数？ 通过指针调用成员函数，只跟指针类型有关系
    pb->Print(); 
    return 0;
}

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

2.Fun和Do

/*A::Fun
C::Do*/ 
#include <iostream> 
using namespace std;
class A { 
    private: 
    int nVal; 
    public: 
    void Fun() 
    { cout << "A::Fun" << endl; }; 
    void Do() 
    { cout << "A::Do" << endl; } 
}; 
class B:public A { 
    public: 
    virtual void Do() 
    { cout << "B::Do" << endl;} 
}; 
class C:public B { 
    public: 
    void Do( ) 
    { cout <<"C::Do"<<endl; } 
    void Fun() 
    { cout << "C::Fun" << endl; } 
}; 
/*函数的参数传入的是B &p,
Fun函数没有多态，执行的是A（B中没有Fun这个函数，所以调用的是基类中的Fun，Do函数多态，执行的是C::Do*/
void Call(//输入代码 派生类对象可以赋值给基类引用，然后看看是函数不是多态 
 B &p
 ) { 
    p.Fun(); p.Do(); 
} 
int main() { 
    C c; 
    Call( c); 
    return 0;
}

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

3.这是什么鬼delete

/*
destructor B
destructor A
*/ 
#include <iostream> 
using namespace std;
class A 
{ 
public:
    A() { }
// 在此处补充你的代码
    virtual ~A(){ cout << "destructor A" << endl; } 
}; 
class B:public A { 
    public: 
    ~B() { cout << "destructor B" << endl; } 
}; 
//我们知道一般析构顺序是派生类到基类，但是如果是基类的指针指向派生类，
//如果基类的析构函数不设置为虚函数，那么就程序就只会调用基类的析构函数，不会调用派生类的析构函数
//考察虚析构函数，一个类作为基类，析构函数应该设为虚函数 
int main() 
{ 
    A * pa; 
    pa = new B; 
    delete pa; 
    return 0;
}

备注：

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

 

 4.怎么又是Fun和Do

/*
A::Fun
A::Do
A::Fun
C::Do
*/ 
#include <iostream>
using namespace std;
class A {
    private:
    int nVal;
    public:
    void Fun()
    { cout << "A::Fun" << endl; };
    virtual void Do()
    { cout << "A::Do" << endl; }
};
class B:public A {
    public:
    virtual void Do()
    { cout << "B::Do" << endl;}
};
class C:public B {
    public:
    void Do( )
    { cout <<"C::Do"<<endl; }
    void Fun()
    { cout << "C::Fun" << endl; }
};
void Call(
// 在此处补充你的代码
A*p
) {
    p->Fun(); p->Do();
}
int main() {
    Call( new A());
    Call( new C());
    return 0;
}

备注：这道题又是填Call的参数，跟第二题差不多，只不过这是多态的第一种情况，通过指针来实现。