程序设计与算法（三）多态 作业

1:看上去像多态

答案：

#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{
private:
    int tt;
public:
    void Print(){
        B::Print();
        cout<<"nDVal="<<tt<<endl;
    }
    void Fun(){
        cout<<"D:Fun"<<endl;
    }
    D(int t_):B(3*t_), tt(t_){}
};

int main() {
    B * pb; D * pd;
    D d(4); d.Fun();//D的带参构造函数，调用d的fun
    pb = new B(2); pd = new D(8);
    pb -> Fun(); pd->Fun();
    pb->Print ();
    pd->Print ();//这里是24,这里调用了pd的Print，如果不重写，就只能调用B的了
    pb = & d;
    pb->Fun();//B::Fun
    pb->Print();//nBVal=12
    return 0;
}

/*
D::Fun
B::Fun
D::Fun
nBVal=2
nBVal=24
nDVal=8
B::Fun
nBVal=12
 */

2、fun和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; }
};
void Call(

B &p // 这个位置，设置为B的引用，由于B的Do是虚函数，因此C的函数D也是虚函数，调用C的do函数，
// 但是调用Fun是由于继承，因此调用到了A的Fun方法。

) {
    p.Fun(); p.Do();
}
int main() {
    C c;
    Call( c);
    return 0;
}
/*
A::Fun
C::Do
 */

3、这是什么鬼delete

#include <iostream>
using namespace std;
class A
{
public:
    A() { }
    virtual ~A(){
        cout<<"destructor A"<<endl;//这里设置为虚析够函数，才可以在delete的时候先消子类在消父类
    }

};
class B:public A {
public:
    ~B() { cout << "destructor B" << endl; }
};
int main()
{
    A * pa;
    pa = new B;
    delete pa;
    return 0;
}

/*
destructor B
destructor A
 */

4、怎么又是fun和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();//这里传入c类的时候，由于Do一直都是虚函数，因此会按照继承的顺序向上找，因此会输出A:Do了
}
int main() {
    Call( new A());
    Call( new C());
    return 0;
}

/*
A::Fun
A::Do
A::Fun
C::Do
 */