c++的多态(重载、覆盖、隐藏)

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/u010246947/article/details/80168950

    描述这类的文章有很多,这里用最简洁的方式用于记牢:

    1、什么是重载(overload):

        在同一个作用域下的两个同名函数,并且它们的参数不同(返回值是否相同可选),这样的两个函数叫重载。

        注意理解"在同一个作用域下",至少包括以下:

        a. 在同一个名字空间下面,比如都在名字空间abcde下定义的两个普通函数,或者两个全局函数;

        b. 在同一个类型下的同一个作用域下,比如都在class A下的public/protected/private;

        重载是"静态联编(静态绑定)"的一种。

        

        插:所谓的"联编(或者叫绑定)",是指"将一个标识符号,和一个存储地址关联起来"。"联编"分为两种,一种是"静态联编",指的是编译时即确定关联关系,包括:普通函数重载、类成员函数重载、运算符重载、模板重载、隐藏(没有修饰以virtual的父子类同名成员函数);一种是"动态重载",指的是运行时确定调用哪个,包括:覆盖。"静态联编"和"动态联编"共同组成了c++的"多态"功能。


        如下面的两个全局函数:

double overload_sample_0 () {
    std::cout << "overload sample 0_1 in namespace what_is_overload" << std::endl;
    return 1.1;
}
int overload_sample_0 (int a) {
    std::cout << "overload sample 0_2 in namespace what_is_overload" << std::endl;
    return 1;
}

        两个函数的名称都是overload_sample_0,作用域都是全局作用域,参数不一样,重载;

        再如下面的两个函数:

namespace what_is_overload {
    void overload_sample_1 () {
        std::cout << "overload sample 1_1 in namespace what_is_overload" << std::endl;
    }
    int overload_sample_1 (int a) {
        std::cout << "overload sample 1_2 in namespace what_is_overload" << std::endl;
        return 0;
    }
};

        两个函数的名称都是overload_sample_1,作用域都是名字空间what_is_overload之下,参数不一样,重载;

        再如下面的函数:

class cls {
    public:
        cls() = default;
        ~cls() = default;
        cls(const cls &other) = default;
        cls(cls &&other) = default;

        void overload_1 (){ std::cout << "overload 1" << std::endl; }
        void overload_1 (int a){ std::cout << "overload 1" << std::endl; }
        //int overload_1 () { std::cout << "overload 1" << std::endl; return 0; } // could not be distinguished with the first one
        int overload_1 (char c) { std::cout << "overload 1" << std::endl; return 0; }

    protected:
        void overload_2 (){ std::cout << "overload 2" << std::endl; } 
        void overload_2 (int a){ std::cout << "overload 2" << std::endl; }
        //int overload_2 () { std::cout << "overload 2" << std::endl; return 0; } // could not be distinguished with the first one
        int overload_2 (char c) { std::cout << "overload 2" << std::endl; return 0; }

    private:
        void overload_3 (){ std::cout << "overload 3" << std::endl; }
        void overload_3 (int a){ std::cout << "overload 3" << std::endl; }
        //int overload_3 () { std::cout << "overload 3" << std::endl; return 0; } // could not be distinguished with the first one
        int overload_3 (char c) { std::cout << "overload 3" << std::endl; return 0; }
    };

        public、protected、private下,都有各自内部的类成员函数的,函数名相同,作用域相同,参数不一样,重载;


        插:描述重载时,很多文章注重说,函数的名称一样,参数、返回值不同,事实上精确的是 ,函数的参数必须不同。试想下面两个函数:

        int overload(){.....}

        double overload() {.....}

        然后调用时:overload();    //which one?

        函数的参数一样,编译器怎么可能区分调用时调用的是哪一个。


    2、什么是覆盖(override):

        父子类中的同名、同参数、同返回值的多个成员函数,从子到父形成的关系称为覆盖关系。

        覆盖关系属于"动态联编",即运行时通过确定指针所指向的是哪个对象,决定运行哪个实现,支撑"动态联编"的是虚函数表,关于虚函数表:

        a. 什么是虚函数表:对含有"virtual"修饰符的类,编译器在编译时,会给该类型制造一个该类型所属的虚函数表;

        b. 虚函数表本质上是:一个函数指针表,类的函数名-----地址,这个函数必须用virtual修饰过;

        c. 虚函数表在哪:在应用程序的常量区;

        d. 虚函数表怎么作用:运行时,根据指针所对应的对象是哪个类型的对象,从虚函数表中找到对应函数名的地址进而执行;

        对析构函数用virtual修饰是典型的覆盖的运用,当(父类指针指向的)子类对象发生析构时:

        a. 如果父类的析构函数用virtual修饰,那么析构时,通过"动态联编"会调用子类的析构函数;然后自然析构父类;

        b. 如果父类的析构函数没有用virtual修饰,那么析构时,仅仅自然析构父类;这个过程实际就是所谓的隐藏;


        参考下面的代码:

//what is inherit? inherit is that father and son has the same function name and the same arg and same return-value
//in c++11, if do want to override, you'd better explicit notice the son function with "override", so compiler will do know that it is inherit, but not another base-virtual-function.
    class father {
    public:
        father() = default;
        //~father() { std::cout << "father destruct" << std::endl; };
        ~father() { std::cout << "father destruct" << std::endl; };
        father(const father &other) = default;
        father(father &&other) = default;

        virtual void inherit () { std::cout << "inherit, father" << std::endl; }
    };
    class son : public father {
    public:
        son() = default;
        //~son() { std::cout << "son destruct" << std::endl; };
        virtual~son() { std::cout << "son destruct" << std::endl; };
        son(const son &other) = default;
        son(son &&other) = default;

//explicit notice compiler that, inherit_c11 here is override of function inherit
//if qualify with "final", class grandson could not override.
//"override" and "final" is used in c++11
        virtual void inherit () override { std::cout << "inherit, son" << std::endl; }
        //virtual void inherit () override final { std::cout << "inherit, son" << std::endl; }
    };

    class grandson : public son {
    public:
        grandson() = default;
        virtual ~grandson() { std::cout << "grandson destruct" << std::endl; };
        grandson(const grandson &other) = default;
        grandson(grandson &&other) = default;

        virtual void inherit () override final {std::cout << "inherit, grandson" << std::endl;  }
    };

        父类、子类、孙类,相继是public的继承关系,析构函数均用virtual修饰,下面依次是实验的方式的知识点的巩固:

        a. 如果析构函数去除了virtual修饰,那么尝试下面的测试,看看差别在哪:

son s

        仅仅在栈中定义了son类型的变量s,析构时,可以发现父类也会被析构;

std::shared_ptr<father> p((father *)new son());
        用father指针,指向在堆中创建的son对象,析构时,可以发现仅仅析构了父类对象,即发生内存泄漏;隐藏;
std::shared_ptr<son> pfs((son *)new father());

        用son指针,指向在堆中创建的father对象,这时程序会崩溃;如果加virtual修饰,会正常析构父类对象;

        结论:

        1、父子类的析构函数,要加入virtual修饰;

        2、不要用子类指针,指向父对象;

              用父类指针指向子类对象,实际开发中是具备实际意义的,是动态实现多态的使用呈现。

              而反过来是令人奇怪的,因为子类已经继承了父类的方法,为什么要用子类指针指向父类对象。


        对于普通函数的覆盖,和析构函数是一样道理。注意:

        1、构造函数不可以进行覆盖;

        2、运算符重载属于重载,不可以进行覆盖;

        3、要保证覆盖的函数,函数参数、返回值均相同;


        一定要加入virtual修饰符,但有时可能会忘记,如果忘记则可能会出现隐藏:

        1、父类有成员函数function;没有用virtual修饰;

        2、子类有成员函数function,函数名、参数、 返回值均相同;

        那么如下面的例子,会出现问题:

std::shared_ptr<father> psf((father *)new son());

        这时如果执行psf->function(),不会在运行时"动态联编",而是出现如下情况:那么指针是什么类型,就执行哪个类型的function;或者说,override退化成hide;隐藏(hide)一般属于程序开发bug;

        为了防止忘写virtual导致的隐藏,c++11规定可以在程序中,对希望是覆盖的成员函数,显式的修饰以override,这样如果没写virtual会在编译时报错,避免忘修饰virtual;

        c++11另外还规定了修饰符final,对于不想再被子类覆盖的虚函数,加入final修饰符,它的子类即便想覆盖也无妨再覆盖了,或者说,覆盖行为到它这里截止;

        

    3、什么是隐藏(hide):

        知道了什么是覆盖,那么忘记修饰virtual导致的"覆盖失误"就是隐藏。隐藏的特点是:不管指针实际指向的对象是什么样的类型,完全根据指针类型,执行对应的成员函数。

        隐藏导致编译器完全没有创建虚函数表(因为没有virtual修饰符),所以完全走的是"静态联编",即按指针类型来。隐藏的危害发生在,原本希望是覆盖,结果发现和预期完全不符。

        下面是隐藏的一些例子:

TEST (test1, what_is_hide) {
//hide: father class and son class, has the function with same name, but without qualify with 'virtual', type of pointer would determine which would be call
    class father {
    public:
        father() = default;
        ~father() = default;
        father(const father &other) = default;
        father(father &&other) = default;

//for hide, whether return-value is also same, is not necessary.so hide_0 equals hide_1
        void hide_0 () { std::cout << "hide_0, father" << std::endl; }
        void hide_1 () { std::cout << "hide_1, father" << std::endl; }
        void hide_2 (int a) { std::cout << "hide_2, father" << std::endl; }
    };

    class son : public father {
    public:
        son() = default;
        ~son() = default;
        son(const son &other) = default;
        son(son &&other) = default;

        void hide_0 () { std::cout << "hide_0, son" << std::endl; }
        int hide_1 () { std::cout << "hide_1, son" << std::endl; }
        void hide_2 () { std::cout << "hide_2, son" << std::endl; }
    };

//when hide, type of pointer determine which would be call
//hide explains that why destruct-function without virtual, would memory leak. destruct-function without virtual, would determined by type of pointer, but not type of object
    father f;
    son s;
    f.hide_0(); //father
    f.hide_1(); //father
    f.hide_2(1);//father
    s.hide_0(); //son
    s.hide_1(); //son
    s.hide_2(); //son

    std::shared_ptr<son> ps(new son());
    ps->hide_0();   //son
    ps->hide_1();   //son
    ps->hide_2();   //son

    std::shared_ptr<son> psf((son *)new father());
    psf->hide_0();  //son
    psf->hide_1();  //son
    psf->hide_2();  //son

    std::shared_ptr<father> pf(new son());
    pf->hide_0();   //father
    pf->hide_1();   //father
    pf->hide_2(1);   //father

    std::shared_ptr<father> pfs((father *)new son());
    pfs->hide_0();  //father
    pfs->hide_1();  //father
    pfs->hide_2(2);  //father
}


        c++多态的总结:

        1、"静态联编":

            1、同一作用域(相同名字空间,类型下相同作用域(public/protected/private))的普通/成员函数,函数名相同,参数不相同;

            2、运算符重载;

            3、编译时确定模板实现类(模板重载);

            如:template<class T> class A{ T data}; A<int> a;

            4、隐藏;隐藏是程序开发的bug应该加以避免;

        2、"动态联编":

            指的就是覆盖,运行时由虚函数表根据所处对象的类型,确定执行哪一个函数;

            良好的程序应该使用覆盖;

        3、如何避免覆盖变成隐藏:

            a. 不要忘了用virtual修饰;

            b. 同时使用override修饰,忘了用virtual时编译器可以报错;

        

        

展开阅读全文

没有更多推荐了,返回首页