Re: Template cannot access its own protected members? huh?

On Thursday, April 10, 2014 2:46:05 PM UTC-5, Victor Bazarov wrote:


SNIP

Here we go. You can replace boost::shared_ptr with std::shared_ptr in C++'11:

// Boost Includes
#include <boost/shared_ptr.hpp>

//------------------------------------------------
class IRetainable
{
public:
    virtual ~IRetainable() {};
protected:
    virtual void Relinquish() = 0;
    virtual void Retain() = 0;
};

//------------------------------------------------
class MyTestClass;

//------------------------------------------------
template<class T>
class RetainedV2
{
public:
    // TODO - This is my question:
    /// I am not sure why we must friend possible T types of this class
    // What are they calling? I know we are calling their Retain and Relinquish,
    // but not the other way around.
    /// If we do not, the compiler gives a nonsensical error message:
    // 'RetainedV2<MyTestClass>::Retain' : cannot access protected member declared in class 'RetainedV2<MyTestClass>'
    // The class cannot access its own protected members? huh?
    //friend MyTestClass;

    RetainedV2(const boost::shared_ptr<T> & resource);
    RetainedV2(const RetainedV2<T> & rhs);
    ~RetainedV2();
    RetainedV2<T> & operator = (const boost::shared_ptr<T> & rhs);
    boost::shared_ptr<T> operator -> () const;
protected:
    void Retain();
    void Relinquish();
private:
    bool m_isRetained;
    boost::shared_ptr<T> m_resource;
};

//------------------------------------------------
template<class T>
RetainedV2<T>::RetainedV2(const boost::shared_ptr<T> & resource)
:
m_resource(resource),
m_isRetained(false)
{
    Retain();
}

//------------------------------------------------
template<class T>
RetainedV2<T>::RetainedV2(const RetainedV2<T> & rhs)
:
m_resource(rhs.m_resource),
m_isRetained(false)
{
    Retain();
}

//------------------------------------------------
template<class T>
RetainedV2<T>::~RetainedV2()
{
    Relinquish();
}

//------------------------------------------------
template<class T>
RetainedV2<T> & RetainedV2<T>::operator = (const boost::shared_ptr<T> & rhs)
{
    Relinquish();
    m_resource = rhs;
    Retain();

    return *this;
}

//------------------------------------------------
template<class T>
void RetainedV2<T>::Retain()
{
    if (m_resource && !m_isRetained)
    {
        m_resource->Retain();
        m_isRetained = true;
    }
}

//------------------------------------------------
template<class T>
void RetainedV2<T>::Relinquish()
{
    if (m_resource && m_isRetained)
    {
        m_resource->Relinquish();
        m_isRetained = false;
    }
}

//------------------------------------------------
template<class T>
boost::shared_ptr<T> RetainedV2<T>::operator -> () const
{
    return m_resource;
}

//------------------------------------------------
//------------------------------------------------
class MyTestClass : private IRetainable
{
public:
    typedef boost::shared_ptr<MyTestClass> SharedPtr;

    // I understand why these friend declarations are needed.
    // Because these methods cal protected methods in this class.
    // and I need them to be protected, because I don't want anyone else
    // to be able to call them.
    friend void RetainedV2<MyTestClass>::Retain();
    friend void RetainedV2<MyTestClass>::Relinquish();

    MyTestClass()
    {
    }
    ~MyTestClass()
    {
    }

protected:
    void Retain()
    {
    }
    void Relinquish()
    {
    }
};

//------------------------------------------------
int main()
{
    boost::shared_ptr<MyTestClass> myTestClass(new MyTestClass());
    RetainedV2<MyTestClass> retained(myTestClass);

    return 0;
}