Abstract Classes
Go Up to Polymorphic Classes Index
An abstract class is a class with at least one pure virtual function. A virtual function is specified as pure by setting it equal to zero.
An abstract class can be used only as a base class for other classes. No objects of an abstract class can be created. An abstract class cannot be used as an argument type or as a function return type. However, you can declare pointers to an abstract class. References to an abstract class are allowed, provided that a temporary object is not needed in the initialization. For example,
class shape { // abstract class point center; // ... public: where() { return center; } move(point p) { center = p; draw(); } virtual void rotate(int) = 0; // pure virtual function virtual void draw() = 0; // pure virtual function virtual void hilite() = 0; // pure virtual function // ... } shape x; // ERROR: attempt to create an object of an abstract class shape* sptr; // pointer to abstract class is OK shape f(); // ERROR: abstract class cannot be a return type int g(shape s); // ERROR: abstract class cannot be a function argument type shape& h(shape&); // reference to abstract class as return // value or function argument is OK
Suppose that D is a derived class with the abstract class B as its immediate base class. Then for each pure virtual function pvf in B, if D does not provide a definition for pvf, pvf becomes a pure member function of D, and D will also be an abstract class.
For example, using the class shape previously outlined,
class circle : public shape { // circle derived from abstract class int radius;// private public: void rotate(int) { } // virtual function defined: no action // to rotate a circle void draw(); // circle::draw must be defined somewhere }
Member functions can be called from a constructor of an abstract class, but calling a pure virtual function directly or indirectly from such a constructor provokes a run-time error.