C++: Using base class's private members in equality test

Question

I would like the following to compile, but it does not:

template <typename T>
struct Odp
{
public:
    operator*() const
    {
        return m_p;
    }

    T* operator->() const
    {
        return m_p;
    }

    T** operator&()
    {
        return &m_p;
    }

private:
        T* m_p;

};

struct Ftw : public Odp<int>
{
    bool operator==(const Ftw& rhs)
    {
        return m_p == rhs.m_p; // C2248 cannot access private member
    } 
};

Is there any way to make this work? I can't modify Odp.

Answer 1

The compiler is telling you that m_p is private. If you want to access m_p in the derived class you need to make it either protected or public.

Answer 2

Odp overloads operator* to return m_p. You can invoke the operator on *this and rhs:

struct Ftw : public Odp<int>
{
    bool operator==(const Ftw& rhs) const
    {
        return **this == *rhs;
    } 
};

The operator* overload is a bit unusual, however: it should probably return *m_p instead, since operator-> returns m_p (this would result in your class having consistent pointer-like semantics). If you did this, you would then have to do the following to do the comparison:

return &**this == &*rhs; // or explicitly as:
return &this->operator*() == &rhs.operator*();

This is getting a bit messy, and it won't necessarily work if the unary & is overloaded for T (but, you really, really shouldn't do that...). You can also obtain the pointer by explicitly calling operator->, which might be preferable:

return this->operator->() == rhs.operator->();

The real question is, "what is this Odp, why are you using it, and why can you not modify it?"

---

On an unrelated note, your operator== should either be implemented as a const member function or, preferably, as a friend function:

bool operator==(const Ftw& rhs) const { /* ... */ }
friend bool operator==(const Ftw& lhs, const Ftw& rhs) { /* ... */ }

On another unrelated note, overloading the unary & is almost certainly a bad idea.

Answer 3

If you can't modify Odp, you can call operator->() explicitly. It returns what you need and should get inlined.

Answer 4

Since Odp is giving the pointer out for free in its methods (even the address of it, OMG! it's like making door with many locks and then giving the keys to every thief around), you can just do

bool operator==(const Ftw& rhs)
{
    return **this == *rhs;
}

Had Odp implemented its own comparison operator, you could use it like this:

bool operator==(const Ftw& rhs)
{
    return Odp<int>::operator==(rhs) && ... other conditions ...;
}