We can also specify that a virtual function is pure virtual (abstract), by appending = 0 to the declaration. Classes with one or more pure virtual functions are considered to be abstract, and cannot be instantiated; only derived classes which define, or inherit definitions for, all pure virtual functions can be instantiated.
struct Abstract {
virtual void f() = 0;
};
struct Concrete {
void f() override {}
};
Abstract a; // Error.
Concrete c; // Good.Even if a function is specified as pure virtual, it can be given a default implementation. Despite this, the function will still be considered abstract, and derived classes will have to define it before they can be instantiated. In this case, the derived class’ version of the function is even allowed to call the base class’ version.
struct DefaultAbstract {
virtual void f() = 0;
};
void DefaultAbstract::f() {}
struct WhyWouldWeDoThis : DefaultAbstract {
void f() override { DefaultAbstract::f(); }
};There are a couple of reasons why we might want to do this:
virtual. This can be useful when making interfaces.
struct Interface {
virtual ~Interface() = 0;
};
Interface::~Interface() = default;
struct Implementation : Interface {};
// ~Implementation() is automatically defined by the compiler if not explicitly
// specified, meeting the "must be defined before instantiation" requirement.class SharedBase {
State my_state;
std::unique_ptr<Helper> my_helper;
// ...
public:
virtual void config(const Context& cont) = 0;
// ...
};
/* virtual */ void SharedBase::config(const Context& cont) {
my_helper = new Helper(my_state, cont.relevant_field);
do_this();
and_that();
}
class OneImplementation : public SharedBase {
int i;
// ...
public:
void config(const Context& cont) override;
// ...
};
void OneImplementation::config(const Context& cont) /* override */ {
my_state = { cont.some_field, cont.another_field, i };
SharedBase::config(cont);
my_unique_setup();
};
// And so on, for other classes derived from SharedBase.