Polimorfismo en tiempo de ejecución en varios tipos de herencia en C++

Posted on by Rudeus Greyrat

C++ permite a los usuarios utilizar el concepto de polimorfismo en tiempo de ejecución utilizando funciones virtuales para cualquier tipo de herencia .

A continuación se muestra cómo implementar el polimorfismo en tiempo de ejecución en todos los tipos de herencia:

  1. Herencia Única:

    // C++ program to demonstrate Run Time
    // Polymorphism in Single Inheritance
      
    #include <iostream>
    using namespace std;
      
    // Base Class
    class Base {
      
    public:
        // Virtual function
        virtual void funct1()
        {
            cout << "Base::funct1() is called\n";
        }
      
        // Virtual function
        virtual void funct2(int x)
        {
            cout << "Base's Val of x:"
                 << x << endl;
        }
      
        // Non-Virtual Function
        void funct3()
        {
            cout << "Base is the Parent class!"
                 << endl;
        }
    };
      
    // Derived Class or Sub Class
    class Derived : public Base {
    private:
        // Virtual Functions
        // can also be Private!
        void funct1()
        {
            cout << "Derived::funct1() is called\n";
        }
        void funct2(int x)
        {
            cout << "Derived Class's Val of x:"
                 << x << endl;
        }
        void funct3()
        {
            cout << "It's the Derived class's"
                 << " funct3() called!" << endl;
        }
    };
      
    int main()
    {
      
        // Run-Time Polymorphism
        // in Single Inheritance
        Base* bptr = new Derived();
      
        // virtual function
        bptr->funct1();
      
        // virtual function
        bptr->funct2(12);
      
        // Non-virtual function
        bptr->funct3();
      
        return 0;
    }
    Producción:

    Derived::funct1() is called
Derived Class's Val of x:12
Base is the Parent class!
  2. Herencia múltiple:

    #include <iostream>
    using namespace std;
      
    // Parent to Derived class
    class Base1 {
    public:
        // Non-Virtual function
        void funct1()
        {
            cout << "Base1::funct1() is called\n";
        }
      
        // Virtual function
        virtual void funct2(int x)
        {
            cout << "Base1's Val of x:"
                 << x << endl;
        }
      
        // Non-Virtual Function
        void funct3()
        {
            cout << "Base1 is the Parent class!"
                 << endl;
        }
    };
      
    // Second Parent to Derived class
    class Base2 {
    public:
        void funct1()
        {
            cout << "Base2::funct1() is called\n";
        }
        void funct2(int x)
        {
            cout << "Base2's Val of x:" << x << endl;
        }
      
        // Only Virtual Function
        // in Base2 Parent class
        virtual void funct3()
        {
            cout << "Base2 is Also a Parent class!"
                 << endl;
        }
    };
      
    // Derived Class of Base1 and Base2
    class Derived : public Base1, public Base2 {
    private:
        void funct1()
        {
            cout << "Derived::funct1() is called\n";
        }
        void funct2(int x)
        {
            cout << "Derived Class's Val of x:"
                 << x << endl;
        }
        void funct3()
        {
            cout << "Derived::funct3() is called "
                 << "and not Base2::funct3() due"
                 << " to RTP" << endl;
        }
    };
      
    int main()
    {
        Derived d;
      
        // Run-Time Polymorphism
        // in Multiple Inheritance
        Base1* b1ptr = &d;
      
        // Compile-Time Binding,
        // Hence Base1::funct1() will be called!
        b1ptr->funct1();
      
        // virtual function of Base1
        // RunTime PolyMorphism
        b1ptr->funct2(10);
      
        // Now Parent Class Base2
        // is also pointed to object 'd'
        // of Derived (to demonstrate RTP)
        Base2* b2ptr = &d;
      
        // virtual function of Base2
        // RunTime PolyMorphism
        b2ptr->funct3();
      
        return 0;
    }
    Producción:

    Base1::funct1() is called
Derived Class's Val of x:10
Derived::funct3() is called and not Base2::funct3() due to RTP

    Nota: Aquí, tanto el puntero Base1 como el puntero Base2 pueden apuntar al mismo objeto de clase derivada ‘d’, pero en realidad el compilador selecciona diferentes funciones virtuales durante el tiempo de ejecución debido al uso de diferentes punteros de clase base.

  3. Herencia multinivel:

    // C++ Program to illustrate Run-Time
    // Polymorphism in multi-level inheritance
      
    #include <iostream>
    using namespace std;
      
    // Parent Class
    class Base1 {
    public:
        // Virtual function
        virtual void funct1()
        {
            cout << "Base1::funct1() is called\n";
        }
      
        // Virtual function
        virtual void funct2(int x)
        {
            cout << "Base1's Val of x:"
                 << x << endl;
        }
      
        // Non-Virtual Function
        void funct3()
        {
            cout << "Base1 is the Parent class!"
                 << endl;
        }
    };
      
    // Derived Class of Base1
    // but Parent to Base3
    class Base2 : public Base1 {
      
        // Virtual Functions can be Private!
    private:
        void funct1()
        {
            cout << "Base2::funct1() is called\n";
        }
        void funct2(int x)
        {
            cout << "Base2's Val of x:"
                 << x << endl;
        }
        void funct3()
        {
            cout << "Base2 is the first "
                 << "Derived class!" << endl;
        }
    };
      
    // Derived Class of Base2
    // but Parent to Derived
    class Base3 : public Base2 {
    private:
        void funct1()
        {
            cout << "Base3::funct1() is called\n";
        }
        void funct2(int x)
        {
            cout << "Base3's Val of x:"
                 << x << endl;
        }
        void funct3()
        {
            cout << "Class Base3 is second "
                 << "Derived class!" << endl;
        }
    };
      
    // 3 Levels of Multi-Level Inheritance
    // and final Child Class
    class Derived : public Base3 {
    private:
        void funct1()
        {
            cout << "Derived::funct1() is called\n";
        }
        void funct2(int x)
        {
            cout << "Derived Class's Val of x:"
                 << x << endl;
        }
        void funct3()
        {
            cout << "Class Derived is Final"
                 << " Child class!" << endl;
        }
    };
      
    int main()
    {
      
        // Run-Time Polymorphism
        // in multi-level Inheritance
        Base1* b1ptr = new Derived;
      
        b1ptr->funct1();
        b1ptr->funct2(30);
      
        // Compile-Time Binding
        b1ptr->funct3();
      
        return 0;
    }
    Producción:

    Derived::funct1() is called
Derived Class's Val of x:30
Base1 is the Parent class!

    Explicación: en el ejemplo anterior, la clase derivada es la clase secundaria final que hereda de Base3, que hereda de Base2, que finalmente hereda de Base1 (Clase principal a Base2). Pero si ve que el polimorfismo en tiempo de ejecución funciona incluso cuando intenta usar funciones virtuales en la clase Base1 y apunta su puntero a la clase derivada (que es el gran nieto de Base1). Por lo tanto, incluso aquí el polimorfismo en tiempo de ejecución funciona de acuerdo con las reglas estándar.

  4. Herencia jerárquica:

    // C++ Program to illustrate Run-Time
    // Polymorphism in Hierarchical inheritance
      
    #include <iostream>
    using namespace std;
      
    class Base1 {
    public:
        // Virtual function of Parent Class
        virtual void funct1()
        {
            cout << "Base1::funct1() is called\n";
        }
        virtual void funct2(int x)
        {
            cout << "Base1's Val of x:" << x << endl;
        }
      
        // Non-Virtual Function
        void funct3()
        {
            cout << "Base1 is the Parent class!"
                 << endl;
        }
    };
      
    class Base2 : public Base1 {
    private:
        void funct1()
        {
            cout << "Base2::funct1() is called\n";
        }
        void funct2(int x)
        {
            cout << "Base2's Val of x:"
                 << x << endl;
        }
        void funct3()
        {
            cout << "Base2 is the first"
                 << " Derived class!" << endl;
        }
    };
      
    class Base3 : public Base1 {
    private:
        void funct1()
        {
            cout << "Base3::funct1() is called\n";
        }
        void funct2(int x)
        {
            cout << "Base3's Val of x:"
                 << x << endl;
        }
        void funct3()
        {
            cout << "Class Base3 is second"
                 << " Derived class!" << endl;
        }
    };
      
    // Grand-Child_1 of Base1 class
    class Derived1 : public Base3 {
    private:
        void funct1()
        {
            cout << "Derived1::funct1() is called\n";
        }
        void funct2(int x)
        {
            cout << "Derived1 Class's Val of x:"
                 << x << endl;
        }
        void funct3()
        {
            cout << "Class Derived1 is Good!!"
                 << endl;
        }
    };
      
    // Grand-Child_2 of Base1 class
    class Derived2 : public Base3 {
    private:
        void funct1()
        {
            cout << "Derived2::funct1()"
                 << " is called\n";
        }
        void funct2(int x)
        {
            cout << "Derived2 Class's Val "
                 << "of x:" << x << endl;
        }
        void funct3()
        {
            cout << "Class Derived2 is Good!!"
                 << endl;
        }
    };
      
    // Run-Time Polymorphism
    // in Hierarchical Inheritance
    int main()
    {
      
        // Base1 class's(Parent class's)
        // pointer points to Derived1 class
        Base1* b1ptr = new Derived1();
      
        // Run-Time Polymorphism
        b1ptr->funct1();
        Derived2 d2;
      
        // Now the Base1 class pointer
        // points to d2 object(Derived2 class)
        b1ptr = &d2;
      
        // Run-Time Polymorphism
        b1ptr->funct2(30);
      
        // Compile-Time Binding
        b1ptr->funct3();
      
        return 0;
    }
    Producción:

    Derived1::funct1() is called
Derived2 Class's Val of x:30
Base1 is the Parent class!

    Explicación: Aquí, el padre es Base1 y sus nietos son clase Derivada1 y clase Derivada2. Incluso en este caso, cuando el puntero de la clase Base1 apunta al objeto Derived1 o al objeto Derived2, debido a las funciones virtuales (‘VPTR’ y ‘VTABLE’), podemos aplicar aquí el polimorfismo en tiempo de ejecución.

Publicación traducida automáticamente

Artículo escrito por kaushik_C y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *