Runtime Polymorphism and Virtual function

Question

Can we achieve runtime polymorphism(method overriding) without virtual function in C++

I think that since it is runtime it should only be possible through pointers using virtual functions but we can override a function without virtual function and pointers also. Here is the following code.. But will it still be runtime ?

#include <iostream>
using namespace std;
class animal{
public:
    void print(){
        cout<<"I am animal"<<endl;
    }
};
class dog: public animal{
public:
    void print(){
        cout<<"I am dog"<<endl;
    }
};
class cat:public animal{
public:
    void speak(){
        cout<<"meow"<<endl;
    }    
};
int main()
{
    dog obj1;
    obj1.print(); // I am a dog
    cat obj2;
    obj2.print(); // I am animal
    return 0;
}

"we can override a function without virtual function" No we cannot. — n. m. could be an AI
– n. m. could be an AI, Commented Sep 23, 2023 at 20:41
override is a specific keyword used only in conjunction with virtual. But for dynamic(runtime) polymorphism without virtual functions check boost.any's implementation. The real thing we need to avoid is not 'virtual' keyword. We try to keep the data local inside CPU cache; when doing so, the set of used types becomes bounded and known, so we sometimes discard virtual functions to save a few more bytes of memory. — Red.Wave
– Red.Wave, Commented Sep 24, 2023 at 10:41

TooTone · Accepted Answer · 2023-09-24 21:22:44Z

It's certainly true that you can't override a method without virtual functions, as one of the comments mentioned. To achieve any kind of runtime polymorphism, you will need some kind of lookup table either implemented yourself or by the compiler. A relatively recent alternative to virtual functions is to use variants instead. Another great blog post compares virtual functions to std::variant. To quote:

virtual functions – dynamic dispatch via vtable vs std::variant – dynamic dispatch via internal union tag (discriminant) and compile-time generated function pointer table

Example code

#include <memory>
#include <string>
#include <variant>

namespace Virtual
{
struct Animal
{
    virtual ~Animal() = default;
    virtual std::string speak() const = 0;
};
struct Cat : Animal
{
    std::string speak() const override { return "meow"; }
};
struct Dog : Animal
{
    std::string speak() const override { return "woof"; }
};
} // namespace Virtual

namespace Variant
{
struct Cat
{
    std::string speak() const { return "meow"; }
};
struct Dog
{
    std::string speak() const { return "woof"; }
};
using Animal = std::variant<Cat, Dog>;
} // namespace Variant

{
    using namespace Virtual;
    const std::unique_ptr<const Animal> pCat = std::make_unique<Cat>();
    const std::unique_ptr<const Animal> pDog = std::make_unique<Dog>();
    pCat->speak(); // expect "meow";
    pDog->speak(); // expect "woof";
}

{
    using namespace Variant;
    const auto cat = Animal{Cat{}};
    const auto dog = Animal{Dog{}};
    std::visit([](const auto& animal) { return animal.speak(); }, cat); // "meow";
    std::visit([](const auto& animal) { return animal.speak(); }, dog); // "woof"
}

Also illustrates another quote from the blog post

virtual functions - clients must operate using pointer or reference vs std::variant – clients use value type [i.e., wrapping the underlying object in a variant]

Collectives™ on Stack Overflow

Runtime Polymorphism and Virtual function

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related