[C++] OOP - Virtual Functions and Abstract Base Classes

Ordinarily, if we do not use a function, we do not need to supply a definition of the function.

However, we must define every virtual function, regardless of whether it is used, bacuase compiler has no way to determine whether a virtual function is used.

    Quote base("0-201-1", );
    print_total(cout, base, );    // call Quote::net_print

    Bulk_quote derived("0-201-2", , , 0.19);
    print_total(cout, derived, );    // call Bulk_quote::net_print

    base = derived;    　　// copy the Quote part of derived into base
    base.net_print();    // call Quote::net_print

When we call a virtual function on an expression that has a plain type - nonreference and nonpointer -- type, that call is bound at compile time. Both base and derived are plain - nonreference and nonpointer - type

Virtual are resolved at run time only if the call is called through a reference or pointer.

When a derived class override a virtual function, it may, but is not requied to, repeat the virtual keyword. Once a function is declared as virtual, remaining virtual in all the derived classes implicitly.

Virtual functions that have default arguments should use the same value in the base and derived classes.

In some cases, we want to force to call a particular version of the virtual.

    double discounted = baseP->Quote::net_price();

Call the Quote version net_price regardless of the type of object to which baseP actually points. This call can be resolved at compile time.

We can specify a virtual function as a pure virtual function by writing =0 in the place of the function body. The =0 appear only on the declaration of the virtual function in the class body.

A class containing( or inherit without overriding) a pure virtual function is known as an abstract class. We cannot (directly) create a object of a type that is an abstract class.

A abstract class declares the interface of subsequent class to override.

class Disc_quote : public Quote{
public:
    Disc_quote() = default;
    Disc_quote(const string & bookNo, double price, size_t qty, double disc) : Quote(bookNo, price), quantity(qty, discount(disc) { }
    double net_price(size_t) const = ;    // an pure virtual function
protected:
    size_t quantity = ;
    double discount = 0.0;
}

Disc_quote discount;    // error: define an Disc_quote object

Now we can reimplement Bulk_quote to inherit from Disc_quote rather than inherit directly from Quote:

class Bulk_quote: public Disc_quote{
public:
    Bulk_quote() = default;
    Bulk_quote(const string& bookNo, double price, size_t qty, double dis): Disc_quote(bookNo, price, qty, dis){ }
    double net_price(size_t) const override;
};

Reference:

C++ Primer, Fifth Edition, chapter 15 Object-Oriented Programming