美文网首页概念和数理相关C/C++编程
c++多态详解

c++多态详解

作者: 雨幻逐光 | 来源:发表于2020-04-17 16:00 被阅读0次

    多态是面向对象编程的一个特性。它允许一个对象在不同的条件下表现出不同的结果。在c++中有两种多态的表现类型：

    1. 编译时多态(Compile time Polymorphism)。这个也被称为静态绑定(static binding)或者早期绑定(early binding)。
    2. 运行时多态(Runtime binding)。这个也被称为动态绑定(dynamic binding)或者迟绑定(late binding)。

    <1>Compile time Polymorphism

    方法的重载和操作符的重载都属于编译时多态的例子。接下来我们介绍下什么是方法重载。

    方法重载（function overloading）

    方法重载是c++编程的一个特性。它允许我们拥有多个方法名一样的方法，只需要这些方法的参数表是不一样的。所谓的参数表是指参数的数据类型和排列顺序。比如：

    myFunc(int a, float b)的参数表是(int, float)。
myFunc(float a, int b)的参数表是(float, int)。

    上面两个的方法名虽然都是myFunc，但是两个方法的参数表是不一样的。
    总结：
    判断是否符合重载条件只需要判断同名方法的参数是否满足参数的类型，数目， 顺序有存在不同。
    注意：
    如果参数表是一样的，即使方法的返回值不一样也是不合法的。只要参数列表是不同的，方法的返回值可以相同也可以不同。所以重载的条件就是需要参数列表的不同。判定不同的方法就是上面注意中提到的。
    例如：

    // 不合法
int sum(int, int)
double sum(int, int)

    例子1

    #include <iostream>
using namespace std;
class Addition {
public:
    int sum(int num1,int num2) {
        return num1+num2;
    }
    int sum(int num1,int num2, int num3) {
       return num1+num2+num3;
    }
};
int main(void) {
    Addition obj;
    cout<<obj.sum(20, 15)<<endl;
    cout<<obj.sum(81, 100, 10);
    return 0;
}

    输出：

    35
191

    例子2

    #include <iostream>
using namespace std;
class DemoClass {
public:
    int demoFunction(int i) {
        return i;
    }
    double demoFunction(double d) {
        return d;
    }
};
int main(void) {
    DemoClass obj;
    cout<<obj.demoFunction(100)<<endl;
    cout<<obj.demoFunction(5005.516);
   return 0;
}

    输出：

    100
5006.52

    方法重载的优点

    方法重载的主要是增加了代码的可读性和复用性（code readability and code reusability）。想象一下如果没有方法重载这种机制，我们可能要写很多不同的函数名但是操作的本质是一样的。这样代码的可读性就变得很差，而且也会在给函数起什么名字上面多耗精力。

    方法重载的多态表现

    从上面的例子中我们可以看到，方法重载是通过编译时通过不同的参数表来确定不同的版本的函数。调用时根据参数表的内容去找对应的版本的方式来实现多态的。

    <2>Runtime Polymorphism

    方法的重写就是运行时多态的例子。接下来我们介绍下什么是方法的重写。

    方法的覆盖\重写（function overriding）

    方法的覆盖也是c++编程的一种特性。这种机制允许我们在子类中拥有一个和父类一样的方法。子类可以继承了父类的数据成员和成员函数。当我们想要修改继承于父类的某种方法的功能时，我们就可以通过覆盖的机制来实现。通过这种方式，我们就好像在子类当中创建了一个父类对应该方法的新方法。

    例子：

    在重写一个方法时，我们需要保证子类中的方法签名和改写的父类方法一致。这里所指的方法签名是指参数的数据类型和顺序。下面这个例子中，要覆盖的父类方法中并没有任何参数，因此我们子类中的重写方法也不需要任何参数。

    #include <iostream>
using namespace std;
class BaseClass {
public:
   void disp(){
      cout<<"Function of Parent Class";
   }
};
class DerivedClass: public BaseClass{
public:
   void disp() {
      cout<<"Function of Child Class";
   }
};
int main() {
   DerivedClass obj = DerivedClass();
   obj.disp();
   return 0;
}

    输出：

    Function of Child Class

    注意：
    在方法重写中，在父类中对应的方法我们称之为被重写的方法（overridden function），在子类中的方法我们称之为重写方法（overriding function）。

    如何通过子类调用被重写的父类方法

    上面的例子我们看到了子类调用重写的方法。那么如何通过子类来调用父类中被重写的方法（overridden function）呢？我们可以通过用父类引用指向子类的实例的方式来调用我们的父类被重写的方法。用下面的例子来帮助我们理解：

    #include <iostream>
using namespace std;
class BaseClass {
public:
   void disp(){
      cout<<"Function of Parent Class";
   }
};
class DerivedClass: public BaseClass{
public:
   void disp() {
      cout<<"Function of Child Class";
   }
};
int main() {
   /* Reference of base class pointing to
    * the object of child class.
    */
   BaseClass obj = DerivedClass(); 
   obj.disp();
   return 0;
}

    输出：

    Function of Parent Class

    如果你想要在子类中重写的函数（overriding function）中调用父类中被重写的函数（overridden function），你只需要这样做：

    //父类类名::方法名
parent_class_name::function_name

    如果用上面的例子来解释上面这种用法就是：

    BaseClass::disp();

    虚函数

    当我们在父类中申明了一个函数为虚函数时，所有子类中该方法的重写函数都会默认的被认为是虚函数（不管是否有virtual关键字）。现在的问题是我们为什么要讲一个函数声明为虚函数呢？这是为了让编译器明白这个函数的调用必须到运行时间才能确定。只有当对象的类型被确定时，才知道调用哪个版本的函数。
    接下来让我们来看两个例子来帮助理解。分别重写非虚函数的父类函数和重写虚函数的父类函数。

    重写一个非虚函数

    #include<iostream>
using namespace std;
//Parent class or super class or base class
class Animal{
public:
   void animalSound(){
      cout<<"This is a generic Function";
   }
};
//child class or sub class or derived class
class Dog : public Animal{
public:
   void animalSound(){ 
      cout<<"Woof";
   }
};
int main(){
   Animal *obj;
   obj = new Dog();
   obj->animalSound();
   return 0;
}

    输出：

    This is a generic Function

    重写一个虚函数

    #include<iostream>
using namespace std;
//Parent class or super class or base class
class Animal{
public:
   virtual void animalSound(){
      cout<<"This is a generic Function";
   }
};
//child class or sub class or derived class
class Dog : public Animal{
public:
   void animalSound(){ 
      cout<<"Woof";
   }
};
int main(){
   Animal *obj;
   obj = new Dog();
   obj->animalSound();
   return 0;
}

    输出：

    Woof

    总结：

    很显然，重写虚函数的方式使得调用的时候，程序是看对象的类型来决定调用的函数。在第二个覆盖虚函数的例子中，我们可以看见虽然obj指针的指针类型是父类Animal，但是其指向的对象是子类Dog的对象。因此这时候，调用的animalSound是子类中的重写函数而不是父类里头的该函数。接下来我们通过一个例子再来进一步了解下它的特性。

    #include<iostream>
using namespace std;

class Base{
    public:
    Base(){
        std::cout << "Base::Base()" << std::endl;
    }
    ~Base(){
        std::cout << "Base::~Base()" << std::endl;
    }
    void print1(){
        std::cout << "Base::print1()" << std::endl;
    }
    void virtual print2(){
        std::cout << "Base::print2()" << std::endl;
    }
};

class Child:public Base{
    public:
    Child(){
        std::cout << "Child::Child()" << std::endl;
    }
    ~Child(){
        std::cout << "Child::~Child()" << std::endl;
    }
    void print1(){
        std::cout << "Child::print1()" << std::endl;
    }
    void print2(){
        std::cout << "Child::print2()" << std::endl;
    }
};

int main()
{
    
    Base* base = new Base();
    Child* child = new Child();

    base->print1();
    base->print2();
    child->print1();
    child->print2();

    delete base;
    delete child;

    Child* child2 = nullptr;
    child2->print1();
    child2->print2();

    return 0;
}

    输出：

    Base::Base()
Base::Base()
Child::Child()
Base::print1()
Base::print2()
Child::print1()
Child::print2()
Base::~Base()
Child::~Child()
Base::~Base()
Child::print1()
Thread 1: EXC_BAD_ACCESS (code=1, address=0x0)//报错

    我们通过打印的信息能够更加清楚的了解到c++背后的运行机制。

    1. 首先我们创建了两个对象，分别是基类对象和子类对象，并分别用基类指针base和子类指针child指向它们。这个过程对应输出我们可以看出调用了构造函数。其中基类的构造函数被调用了两次。说明在创建子类对象的时候，调用了子类的构造函数，而子类的构造函数会先默认调用父类的构造函数，然后执行自己的构造函数。
    2. 通用基类和子类的指针分别调用print1和print2两个函数。这个地方没什么问题。基类指针指向基类对象，调用的必然是基类中的函数。子类也一样。
    3. 第三步删除对象。这边发现基类的析构函数也被调用了两次。和构造函数相同，子类在调用析构函数的时候，也会调用一次父类的析构函数。不过不同的是调用时期。析构的时候，是在执行完自己的析构函数体后再调用父类的析构。
    4. 最后一个涉及到多态的知识。首先创建了一个子类的指针child2并赋值为空指针nullptr。第一次调用print1，通过输出可以知道，该语句可以正常执行。并且调用的是子类的print1。说明了如果函数不是虚函数的情况下，c++是直接根据指针类型来判断调用的函数版本（到底是基类的，还是基类的版本）。第二句调用print2函数时报错。原因是print2是个虚函数（父类中声明了是虚函数，所有子类重写该函数都默认是虚函数）。通过虚函数的机制我们可以知道，要调用哪个版本（父类的版本还是子类的版本）需要在运行的时候通过指针所指向的对象类型来确定。此时，child2指针指向为空指针（没有指向任何实例对象），因此报错。

    方法重载（function overloading）和方法重写（function overriding）的不同

    到此我们已经理解了什么是c++编程中的方法重载和方法重写。让我们来看看它们的不同：

    1. 方法重载是在同一个类里头完成的。在同一个类中，我们声明方法名相同但是参数列表不一样的方法称为方法重载。
    2. 在方法重载时，我们必须确认函数的签名是不同的。但是在方法重写中，我们必须保证重写方法和被重写方法具有相同的签名。
    3. 方法重载发生在编译期间，因此也被成为编译时多态。而方法覆盖发生在运行期间，因此也被称为运行时多态。
    4. 方法重载时，在一个类中重载的方法数量没有限制。方法重写时，一个子类对应父类的某个方法只能被重写一次。

    参考

    c++方法重载
    c++方法覆盖
    重载vs覆盖
    虚函数

    相关文章

      网友评论

        本文标题：c++多态详解

        本文链接：https://www.haomeiwen.com/subject/cpkzmhtx.html

        延伸阅读

        深度阅读

        • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

        栏目导航

        热点阅读

        概念和数理相关

        C/C++编程

        关于我们|服务条款|联系我们|c++多态详解|投稿指南|网站地图|RSS订阅|排版工具|手机版

        提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

        Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

        备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

        本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

        所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！