How polymorphism can be achieved by means of virtual functions in C plus plus?

Answer 1

Virtual functions of a class are functions (methods) that can be redefined in a child class and, through polymorphism, the correct function will be invoked depending on the type of the class involved. Virtual functions are declared with the virtual keyword... class myclass {

... virtual int myfunction(...);

... etc.

} When a class contains at least one virtual function, a static virtual table (vtable) is implemented Behind the Scenes by the compiler. This table is used to point to the correct implementation for that type of class at run-time. Abstract base classes are a special form of class, where they must be derived. They often declare virtual functions which is the defined interface, but through the keyword "= 0" enforce the requirement that the class be derived, i.e. that the class can not be instantiated directly... class myclass {

... virtual int myfunction(...) = 0;

... etc.

} class mysubclass : public myclass {

... virtual int myfunction(...);

... etc.

}

Answer 2

Polymorphism is the means by which we can generalise different types through a common interface. This is achieved through a combination of inheritance and virtual functions. For instance, we can derive different types of shapes from a common base class named shape:

struct shape {};

struct circle : shape {};

struct triangle : shape {};

struct quadrangle : shape {};

If we assume that each of the derived shapes can somehow be drawn on screen, then we'd expect each to have its own specific draw() method. We can express this concept in our code through a pure-virtual function in the shape class:

struct shape {

virtual draw() = 0;

};

Why pure-virtual rather than just virtual? The shape class is really an abstract class, a conceptual class rather than an actual class. We would expect to instantiate circles and triangles, but we wouldn't expect to instantiate a shape since there is no meaningful way to implement its draw method. So in this case it has to be declared pure-virtual. This ensures that any derived shape must provide a complete implementation of the draw() method, otherwise it becomes an abstract class itself. In other words, every type of shape must provide its own specialisation of the draw() method.

Although we cannot instantiate a shape class in its own right (because it is abstract), every object derived from shape has an underlying shape object. We can therefore say the object "is a kind of" shape. We can therefore create collections of shapes simply by pointing at their common base class:

std::vector<shape*> shapes;

We can then gain polymorphic behaviour by invoking the virtual methods associated with those pointers:

for (auto s : shapes) s->draw();

Note that we do no need to know what types of shape are in the collection since each shape "knows" its own type. When we invoke the draw method associated with shape s, we invoke circle::draw() when s points to a circle and triangle::draw() when s points to a triangle. We can also cater for shapes that do not yet exist. If someone derived an octagon from our shape class, our generic code would still work even though it has no way of knowing what an octagon actually is. So long as it is a kind of shape, polymorphism will ensure it behaves correctly.

We can also refer to the underlying shape:

void rotate (shape& s)

{

s.draw();

}

Here, we can pass any shape-derived object to this function. The code knows nothing about triangles or circles, but it knows about shapes and it knows every shape has a draw method. Thus the object will behave exactly as we expect it to, through polymorphism.

Answer 3

Virtual functions provide default functionality, and sub-classes of a class with virtual functions can override the default behavior on a case-by-case basis. This allows a single master type to divert function calls as needed. For example, consider three classes: vehicle, car, and boat. The parent class, vehicle, might implement the functions addPassenger, startMoving, and animate. In this case, it is likely that addPassenger and startMoving will be non-virtual functions, while animate would probably be a virtual function (they would both use different sprites or animation models). This allows a programmer to make code smaller, and write code faster.