What is difference between virtual base class and virtual function?

Answer 1

A virtual class allows children classes to inherit multiple classes that all share a common ancestor. Without this property, the child class would contain multiple copies of the same parent class. A virtual function is a function, with a body, defined in a parent class that may be overridden in the parent class.

Answer 2

Take a look around you, find me an object which you couldn't classify. In

reality, the whole world around you is classified in some way. Life and

genes, elements and materials, businesses and products, date and time,

energy and work, etc.

The basic idea is that you can classify (no pun intended), contain, upcast,

or provide easy code-expansion for a new object based on its provided

derivative(s).

Common example

A Shape class can be an abstract class to derive a Triangle class, a

Rectangle class and a Circle class. A pure-virtual getArea() member function

in the abstract Shape class requires you to define the getArea() member

function in each of its derivatives. The Circle and the Rectangle, for

example, don't rely on the same getArea() member function to calculate its

area.

Note that this makes OO sense since:

A Triangle is_a Shape

A Rectangle is_a Shape

A Circle is_a Shape

Containers

The benefit is now you can use a container that holds any Shape (an array of

Shapes, a vector, a list, stack, queue, etc). The container needs not track

which shape element is a circle, a triangle or a rectangle. The Shape

container needs only satisfy that each element is a pointer to an existing

Shape derivative.

Shapes* shapes[4]; // a container of pointers to Shape objects

shapes[0] = new Rectangle(10, 10); // (width, length)

shapes[1] = new Circle(5); // (radius)

shapes[2] = new Triangle(7, 6) // (width, length)

shapes[3] = new Circle(22); // (radius)

The element at shapes[0] knows whether its a Circle, Rectangle or Triangle.

The same goes with every other element. The container doesn't care whether

Array[2] is a Triangle, a Rectangle or a Circle. So when you write:

int n = 0;

while ( n < 4 )

{

Array[n++]->getArea();

}

delete [] shapes;

You are calling the appropriate getArea() behaviour for each Shape-type

element in the container (using a vtable). This would not be possible

without the abstract Shape class (a container of what?). Neither would this

be possible without a pure-virtual getArea() member function in Shape (we

need to guarentee that all Shapes have such a member function available).

This ability to contain any derivative-type can be applied to Animals,

Vehicles, Employees, Airplanes, Planets or any other base class you can

think of. Note that the hierarchy need not be so shallow. A Car is a

derivative of Vehicle, a Sportscar is a derivative of Car, hence a Sportscar

can also be an element in a container of Vehicles.

Whats the benefit? All such Vehicles have an engine, a steering wheel and a

gas tank. There is no need to repeatedly insert an engine in all the derived

classes. A Vehicle base class can be composed of an engine and each derived

class needs only invoke the appropriate engine ctor to equip itself with a

particular engine. The startEngine() member function in Vehicle can now

start the engine in any Vehicle. This can save an enormous amount of code

when you consider the variety of motorized vehicle-types out there.

Should a client programmer choose to employ your classes (expand Shape to

provide a pentagon or octagon - expand Vehicle to provide a FireTruck), his

job has been made much easier for both you, the creator, and the client.

You've used a common abstract base class and pure-virtual member functions

which dictates and guarentees the implementation of the new derived entity

in the program.

A quick scan by the client of your base class permits him or her to draw up

the derived FireTruck. The client can add the water pump, the ladder, valves

and whatever he likes or needs. Yet that FireTruck can still be held in any

Vehicle container (highway, FireHouse, bridge, Ferry, Tunnel, etc) and the

original startEngine() member function still works.

The same principles of simplified code reusability can be applied in

virtually any appropriate classification hierarchy.

Answer 3

An abstract class is any base class that has at least one pure virtual function. This means the base class cannot be instantiated other than by derivation. The most-derived class must provide an implementation for the pure virtual function. The base class may provide a generic implementation, however this implementation cannot be inherited and it can only be called explicitly by a derivative. Once a derived class implements the pure virtual function, it reverts to a virtual function with regards to its derivatives and can be inherited. Only class that provide or inherit a complete implementation of all pure virtual methods can be instantiated as objects in their own right. All others are abstract.

A virtual function is a generic base class method that can be overridden by a derived class. When calling the generic method of the base class, the most-derived override is called instead. This allows programmers to work with generic objects whilst invoking specialised methods without the need to know the runtime type of an object. When you declare virtual functions, every class in the hierarchy has its own virtual table which maps the generic methods to their overrides. Although this costs a little memory, it is many times quicker than using runtime type information to determine which specialised methods to call, and reduces code maintenance substantially because the generic type does not need to know the runtime type of its derivatives. In other words, without virtual functions, every base class would need to know the exact type of all its derivatives, which means you would have to update the base class every time you derived a new object from it, and update all methods to cater for that new type, which vastly increases code size. The virtual table provides that functionality for very little cost, performs many times better, and greatly reduces the chances of programmer error.

Answer 4

A virtual function is a member method that is expected to be overridden by derived classes. A pure-virtual function is one that must be overridden in derived classes.

A virtual base class is a base class that is declared virtual in its derivatives. This is commonly used when a derivative inherits from two or more base classes that each inherit from a common base class. Without virtual inheritance, the most-derived class would indirectly inherit multiple instances of the common base class. By declaring the common base class to be virtual in its derivatives, the most-derived class directly inherits the common base class, and the derivatives themselves then share that same instance.

Answer 5

Neither Java nor C# provides a feature to define virtualclasses. Abstract classes may be defined in both languages.

An abstract class is a class contains (and should) at least one abstract method (and properties in c#). The idea is to establish a service contract (the name of the method, the returning type, the arguments, etc, the method signature) but provides no implementation (no method body). The implementation is deferred on purposely to be done in the derived classes. This abstract class has no knowledge what the derived classes will actually do.

Similar to abstract method, there is a virtual method in C# (in Java, every method can be a virtual method in a non-final class), it does provide one of the possibly implementation (with method body). The derived may opt to override it, inherit from that, or perform additional steps before and/or after the default implementation. A class contains at least 1 virtual method DOES NOT make that class a virtual one.

Answer 6

An abstract class is an abstract data type (ADT) or, if you prefer, an abstract base class (ABC). Either way, it is a conceptual class rather than an actual class. You cannot instantiate an ADT/ABC, you can only derive from it. They exist purely to provide a common interface to the derivatives, through the use of pure-virtual methods (methods which the ADT/ABC declare but do not implement).

A virtual class is a base class that is common to two or more derived classes that may be derived through multiple inheritance. If class V is the base class for both A and B, and class D derives from both A and B, then it inherits two instance of V (one from A, the other from B). If it is known in advance that A and B can be used in multiple inheritance, then V should be declared virtual in both A and B. Thus D inherits a single instance of V, which is shared between A and B. For this to work, V should be an ADT/ABC that has a minimal interface and (preferably) no member variables.