c++的覆盖和重载

覆盖 override

指子类重新定义父类的虚函数

在编译期间无法确定，是动态调用，属于晚绑定。

 

重载 overload

指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

其实，重载，并不是面向对象编程。

在编译器间就已经确定了，是静态的，属于早绑定。

 

多态

封装可以隐藏实现细节，使得代码模块化；继承，可以扩展已存在的代码模块。它们的目的都是为了代码重用。

而多态，是为了实现另一个目的，接口重用。

 

class A
{
        protected:
        int m_data;
        public:
                A(int data = 0)
                {
                        m_data = data;
                }
                int GetData()
                {
                        return doGetData();
                }
                virtual int doGetData()
                {
                        return m_data;
                }

};

class B:public A
{
        protected:
        int m_data;
        public:
                B(int data = 1)
                {
                        m_data = data;
                }

                int doGetData()
                {
                        return m_data;
                }

};

class C:public B
{
        protected:
        int m_data;
        public:
                C(int data = 2)
                {
                        m_data = data;
                }

};

void test3()
{
        C c(3);
        cout<<c.GetData()<<endl;
        cout<<c.A::GetData()<<endl;
        cout<<c.B::GetData()<<endl;
        cout<<c.C::GetData()<<endl;
        cout<<c.doGetData()<<endl;

        cout<<c.A::doGetData()<<endl;
        cout<<c.B::doGetData()<<endl;
        cout<<c.C::doGetData()<<endl;
}

class AA
{
        public:
                void virtual f()
                {
                        cout<<"AA"<<endl;
                }
};

class BB:public AA
{
        public:
                void virtual f()
                {
                        cout<<"BB"<<endl;
                }
};

void test4()
{
        AA *pa = new AA();
        pa->f();
        BB* pb = (BB*)pa;
        pb->f();

        delete pa,pb;
        pa = new BB();
        pa->f();
        pb = (BB*)pa;
        pb->f();
}