Question 27 of 28: Interface vs. Class, and Simulating a Java Interface in C++

Question 27: Interface vs. Class, and Simulating a Java Interface in C++ (Part V)

Question text not reproduced: the examination questions are © Engineers and Geoscientists BC. Open the official past paper (linked at the top of this page) to read the question, then follow the worked solution below.

Interface vs. class. A Java class is a full blueprint combining both STATE (instance fields) and BEHAVIOUR (implemented methods), can be instantiated directly if concrete, and supports only SINGLE inheritance of another class. A Java interface declares a pure contract — method signatures (plus, since Java 8, optional default implementations) and constants, with NO instance state and no constructors of its own; a class implementing it must supply concrete implementations of its abstract methods. Critically, a class may implements any number of interfaces — multiple inheritance of TYPE is allowed even though multiple inheritance of class IMPLEMENTATION is not (Question 24's dynamic binding still applies: a call through an interface reference dispatches to whichever concrete class's method actually implements it).

Simulating in C++. C++ has no dedicated interface keyword, but a Java-style interface is simulated with an ABSTRACT CLASS containing ONLY pure virtual functions (= 0) and no data members, no implemented methods (beyond a virtual destructor). Because C++ already permits multiple inheritance of ordinary classes, a class can "implement" several such pure-abstract classes simultaneously — achieving Java's multiple-interface-implementation directly, and safely, because a class with zero data members and zero implemented methods carries none of the diamond-problem ambiguity (conflicting inherited state or behaviour) that motivated Java's restriction to single class inheritance in the first place.

class Printable {
public:
    virtual void print() const = 0;
    virtual ~Printable() = default;
};
class Comparable {
public:
    virtual bool lessThan(const Comparable& other) const = 0;
    virtual ~Comparable() = default;
};
class Item : public Printable, public Comparable {   // "implements" both, like Java
public:
    void print() const override { /* ... */ }
    bool lessThan(const Comparable& other) const override { /* ... */ }
};