多态中的虚函数

• 向上类型转换

enum note {middleC,Csharp,Cflat};
class Instrument {
public:
    void  play(note) const {
        cout << "Instrument::play" << endl;
    }
};

class Wind: public Instrument {
public:
    void  play(note) const {
        cout << "Wind::play" << endl;
    }
};

void ture(Instrument& i) {

    i.play(middleC);
}
int main()
{
    Wind flute;
    tune(flute);
//最终打印结果为Instrument::play，向上类型转换虽然对象属于Wind,
//但是Wind继承于Instrument，这样ture(Instrument& i)即使传入的是Wind类，也能向上转换为Instrument类的对象

}

变为虚函数后的结果就不同了

enum note {middleC,Csharp,Cflat};
class Instrument {
public:
    void  play(note) const {
        cout << "Instrument::play" << endl;
    }
};

class Wind: public Instrument {
public:
    virtual void  play(note) const {
        cout << "Wind::play" << endl;
    }
};

void ture(Instrument& i) {

    i.play(middleC);
}
int main()
{
    Wind flute;
    tune(flute);//最终打印结果为Wind::play ，加上virtual关键字后，就可以保证继承的可扩展性，保证派生类自已拥有不同于基类的功能，实现函数的重新定义。
}

• 抽象基类和纯虚函数

　　在类的设计中，通常将基类作为派生类的一个标准接口，一般不创建基类的对象，建立基础的模板，它的派生类去重新定义函数的功能。纯虚函数禁止对抽象类的函数以传值方式调用，会发生对象切片，通过引用或指针可以避免。

enum note {middleC,Csharp,Cflat};
class Instrument {
public:
    virtual void  play(note) const = 0;
    virtual char*  what() const = 0;
    virtual void  adjust(int) = 0;
};

class Wind: public Instrument {
public:
    void  play(note) const
    {
        cout << "Wind::play" << endl;
    }
    char*  what() const
    {
        return "Wind";

    }
    void  adjust(int) {}
};
class Percussion : public Instrument {
public:
    void  play(note) const
    {
        cout << "Percussion::play" << endl;
    }
    char*  what() const
    {
        return "Percussion";

    }
    void  adjust(int) {}
};
class Stringed : public Instrument {
public:
    void  play(note) const
    {
        cout << "Stringed ::play" << endl;
    }
    char*  what() const
    {
        return "Stringed";

    }
    void  adjust(int) {}
};
class Brass : public Wind {
public:
    void  play(note) const
    {
        cout << "Brass ::play" << endl;
    }
    char*  what() const
    {
        return "Brass";

    }
};
class Woodwind : public Wind {
public:
    void  play(note) const
    {
        cout << "Woodwind ::play" << endl;
    }
    char*  what() const
    {
        return "Woodwind";

    }
};
void ture(Instrument& i) {

    i.play(middleC);
}
void f(Instrument& i)
{
    i.adjust(1);
}
int main()
{
    Wind flute;
    Percussion drum;
    Stringed violin;
    Brass fluge;
    Woodwind recorder;
    tune(flute);
    tune(drum);
    tune(violin);
    tune(fluge);
    tune(recorder);
    f(fluge);
}

• 对象切片

　　解决多态中，基类对象操作派生类对象的问题，对象切片会使基类访问不到派生类，不能使多态有意义。

class Pet {
    string pname;
public:
    Pet(const string& name) :pname(name) {}
    virtual string name() const { return pname; }
    virtual string description()const
    {
        return pname;
    }
};

class Dog : public Pet {
    string factive;
public:
    Dog(const string& name, const string& active) :Pet(name), factive(active) {}
    string description() {
        return factive;
    }
};
void  description(Pet p) //传入的使值，不是引用不是指针地址
{
    cout << p.description() << endl;
}

int main()
{
    Pet p("Alfred");
    Dog d("Fluffy","sleep");
    description(p);
    description(d);
//我们希望description(p)出现Alfred结果，description(d)出现sleep结果，
//但是实际最终的结果是description(d)出现Fluffy，调用的同样是基类的函数，
//而不是派生类的。因为传值的过程不能改变地址。
}

• 重载和重新定义

　　重新定义一个基类的重载函数时，将会隐藏所有该重载函数的其他基类函数，但是当对虚函数进行操作重新定义时会不太一样。下面的d4和引用是其中的区别.

class Base {
public:
    virtual int f()const {
        cout << "Base::f()";
        return 1;
    }
    virtual void f(string) const {}
    virtual void g() const {}
};

class Derived1 :public Base {
public:
    void g() cont {}
};
class Derived2 :public Base {
public:
    int f() cont {
        cout << "Derived2::f()";
        return 2;
    }
};
class Derived3 :public Base {
public:
    /*void f() const {
        cout << "Derived3::f()";
        return 3;
    }*///非法，不能改变返回类型
};
class Derived4 :public Base {
public:
    int f(int) cont {
        cout << "Derived4::f()";
        return 3;
    }
};
int main()
{
    srting s("hello");
    Derived1 d1;
    int x = d1.f();
    d1.f(s);
    Derived2 d2;
    x = d2.f();
    //d2.f(s);隐藏
    Derived4 d4;
    x = d4.f(1);
    //x=d4.f();隐藏
    //d4.f(s);隐藏
    Base& br = d4;
    //br.f(1);
    br.f();
    br.f(s);//与Derived4 d4相反
}