Question

In java, we can define different interfaces and then later we can implement multiple interface for a concrete class.

// Simulate Java Interface in C++
/*
interface IOne {
    void   MethodOne(int i);
    .... more functions
}

interface ITwo {
    double MethodTwo();
    ... more functions
}

class ABC implements IOne, ITwo {
    // implement MethodOne and MethodTwo
}
*/

In C++, generally speaking, we should avoid the usage of multiple inheritance, although multi-inheritance does have its edge on some situations.

class ABC {
public:
    virtual void   MethodOne(int /*i*/) = 0 {}
    virtual double MethodTwo() = 0 {}

    virtual ~ABC() = 0 {}

protected:
    ABC() {} // ONLY ABC or subclass can access it
};

Question1> Based on the design of ABC, should I improve any other things in order to make it a decent ABC?

Question2> Is it true that a good ABC should not contain member variables and instead variables should be kept in the subclasses?

Question3> As I indicated in the comments, what if ABC has to contain too many pure functions? Is there a better way?

Answer 1

1. Do not provide an implementation for pure virtual methods unless it is necessary.
2. Do not make your destructor pure virtual.
3. Do not make your constructor protected. You cannot create an instance of an abstract class.
4. Better hide an implementation of constructor and destructor inside a source file not to pollute other object files.
5. Make your interface non-copyable.

If this is an interface, better do not have any variables there. Otherwise it would be an abstract base class and not an interface.

Too many pure functions is OK unless you can do it with less pure functions.