What is the difference between base class and derived class in c plus plus?

Answer 1

There is no difference other than that a derived class inherits from a base class. That is, the derived class inherits all the public and protected members of its base class, and is a more specialised form of its base class. Thus both can be treated as if they really were base classes. The derived class can also override the virtual methods of the base class, thus allowing polymorphic behaviour without the need to know the exact type of the derived class.

Answer 2

The definition of a base class is any class that declares one or more virtual functions. If any function is declared virtual, the destructor must also be declared virtual.

The only other type of base class is an abstract base class (ABC), also known as an abstract data type (ADT). An ADT must provide one or more pure virtual functions in addition to a virtual destructor. A virtual interface is optional.

The main differences between a virtual function and a pure virtual function is that a pure virtual function must be overridden by a derivative but the ADT that declared it need not provide any implementation. By contrast, a virtual function need not be overridden by a derivative but must be implemented by the base class that declared it.

When a derivative implements a pure-virtual function, that function becomes virtual (non-pure) with regards subsequent derivatives, and those derivatives can therefore inherit that implementation. However, if a derivative does not implement or inherit a complete implementation of a pure-virtual interface, it becomes an ADT itself.

Some people regard virtual base classes as being a type of base class, but this is not strictly true. Virtual base classes simply alter the order of construction, nothing more. In the hierarchy A->B->C where C is the most-derived class, when you instantiate an instance of C the compiler will automatically invoke B's constructor which, in turn, will automatically invokes A's constructor. Only when A is fully constructed can B be fully constructed and only when B is fully constructed can C be fully constructed. But if B inherits from A virtually rather than directly, then A is constructed via C, not via B. Thus when C invokes B's constructor, A is already constructed. Virtual base classes are always constructed first by the most-derived class in the hierarchy (thus if D derived from C, D would invoke A's constructor rather than B). This is useful when two or more base classes share a common base class as the most-derived class simply instantiates a single instance of the virtual base class that is subsequently shared by those base classes. Without virtual base classes, you would have two or more instances of the same base class which not only increases the memory footprint, it also leads to ambiguity regarding which instance is being referred to unless you use explicit member-of references.

In addition, classes that do not declare or inherit a virtual interface can still be used as base classes, however they are not base classes in the strictest sense. At the very least, a base class must have a virtual destructor to ensure correct teardown (most-derived to least-derived), regardless of which class is destroyed first. But without a virtual interface the onus is placed entirely upon the programmer rather than the compiler to ensure the correct polymorphic behaviour is invoked. Virtual interfaces cost a little memory to accommodate the virtual table (v-table), but without this the cost would be even greater because the programmer must use costly runtime type information to enable polymorphic behaviour. This, in turn, increases the maintenance burden upon the programmer. If the class is to be distributed, this would be an unacceptable burden to place upon your consumers.

Answer 3

As many as required. There is no practical limit.