OOP Problem?

One day, I wrote a simple Stack class:

Code:

class LinkedList {

public:
  int value;
  LinkedList *next;

  LinkedList() : next(0) { }
};

class Stack
{
protected:
  LinkedList *top;

public:
  Stack() : top(0) { }
  
  void push( int value );
  int pop();
};

I compiled it and then use it in some project...


3 years later, I need a stack that counts every item that pushed or popped into it
I lost the Stack source code and the only thing left is its header and compiled binary
due to OOP matter, I just extend it then.

Code:

class CountingStack : public Stack
{
protected:
  int count;

public:
  CountingStack() : count(0) { }

  void push( int value ) {
    //count++
  }
  
  int pop() {
    //count--
  }
  
  int getCount();
};

the next year , I need a stack that throws an Exception when it's empty
but it doesn't need to count every item that pushed or popped into it
So I wrote this ExceptionStack

Code:

class ExceptionStack : public Stack
{
public:
  int pop() {
    //throw Exception if the stack is empty ( top == NULL )
  }
};

And now, I need both CountingStack and ExceptionStack features
but again, I lost their source code!
Because of the project's time limit, I couln't rewrite the Stack code.
So, I guess I need to write this kind of class, but I found a problem...

Code:

class CountingExceptionStack : public CountingStack, public ExceptionStack
{
public:
  void push( int value )
  {
    CountingStack::push( value );
  }
  
  /*
  int pop()
  {
    What should I write here??
  }
  */
};

Take std::stack and write your own stack class around it in 5 minutes?

Originally Posted by audinue

I lost the Stack source code and the only thing left is its header and compiled binary
due to OOP matter, I just extend it then.

However, Stack was not designed to be a base class. It has no virtual functions for you to override.

There are two ways to implement CountingStack that I would consider correct. One way is to provide the same interface as Stack, but have a Stack member variable instead of using inheritance, then forward the various member functions (i.e., CountingStack's member functions would just call the corresponding member functions of the Stack member variable). Another way is to use private inheritance, then use using declarations to make the various member functions public, except for push(), which you implement.

For ExceptionStack, there is an even simpler solution, assuming that Stack has an empty() member function that returns true if the stack is empty: define a non-member function that performs the pop() and which throws an exception if the stack is empty. The same solution can be applied for CountingStack. In fact, if you define it as a function template instead, then it will work for any stack class that defines pop() and empty().

Of course, the problem is that Stack does not have a member function that returns true if the stack is empty, and indeed it has no way to determine if the stack is empty. This makes Stack quite useless, but in a real class I would expect that the interface would be sufficient (and class interfaces typically provide too much as member functions, rather than too little, which is not necessarily a good thing).

I think it's safe to say that the stack thing is a metaphor for some considerably more complex class that you cannot reimplement in 5 minutes using standard library facilities.

The answer is, you're screwed. Unless your headers give you a clue that the entire work the two pops did was in a separate helper function that you could call directly, there's no way to get the functionality of both.

If the helper functions are private, you can [i]probably[i] change the visibility specifier in the existing classes without breaking binary compatibility.