How to call protected pure virtual ancestor funcs from friend function?

From:

"Siegfried Heintze" <siegfried@heintze.com>

Newsgroups:

comp.lang.c++.moderated

Date:

Sat, 19 May 2007 07:41:19 CST

Message-ID:

<Sv-dnf7d3JM33NPbnZ2dnUVZ_uuqnZ2d@revealsystems.com>

I have a (surprise!) stack class and I want to implement a compare function
that compares two stacks for equality. What I have below works, but MS
Visual C++ 6 requires that I declare ISTACK<TYPE>::getData public! Arghhh!
Those pure virtual getData functions should be protected! How do I make
them
protected? MSVC 6 gives me syntax errors if I don't make them public! Is
this a bug in the compiler or a bug in the C++ specification? Is there a
fix
other than declaring them public and violating the fundemental concept of a
stack? I tried implementing compare as a member function but then it could
not access the private or protected parts of the stack that is an argument
to the compare member function. Is that conistent with the C++ spec?

Thanks,
Siegfried

template<typename TYPE>
class ISTACK{
public:
      virtual TYPE pop() = 0; //!< Remove the
last element.
      virtual TYPE top() const=0; //!< Copy the
last
element but do not remove it.

public: // should be protected: not public!
      virtual TYPE* getData()=0;
      virtual const TYPE* getData() const=0;
};

template<typename TYPE, int SIZE, char SEP=10>
class STACK : public ISTACK<TYPE> // abstract interface
{
public:
      STACK( ){ len = 0; push(); };
      STACK(TYPE a ){ len = 0; push(a); };

      //template<typename TYPE>
      friend int compare(const ISTACK<TYPE>& left, const ISTACK<TYPE>&
right)
      {
           int lenLeft = left.getLength();
           int lenRight = right.getLength();
           int len = lenLeft < lenRight ? lenLeft : lenRight; // compute
the
min
           if(lenLeft == 0 && lenRight == 0)
           {
           }
           else
           {
                const TYPE*pLeft = left.getData();
                const TYPE*pRight = right.getData();
                for(int ii = 0; ii < len; ++ii)
                {
                     if(pLeft[ii] != pRight[ii])
                     {
                          return pLeft[ii] - pRight[ii];
                     }
                } // they are equal except for extra cells
                if(lenLeft != lenRight)
                {
                     return lenLeft - lenRight;
                }
           }
           return 0;
      }

protected:
      TYPE* getData() { return state; }
private:
      const TYPE* getData() const { return state; }

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]