C++ 如何调用传递定义为受保护类的对象的方法

我已经想了好几个小时了，但还是不明白。。。这是链接列表的开源定义

template <typename T> 
class NPT_List 
{
protected:
    class Item;

public:
    // types
    typedef T Element;

    class Iterator {
    public:
        Iterator() : m_Item(NULL) {}
        explicit Iterator(Item* item) : m_Item(item) {}
        Iterator(const Iterator& copy) : m_Item(copy.m_Item) {}
        T&  operator*()  const { return m_Item->m_Data; }
        T*  operator->() const { return &m_Item->m_Data;}
        Iterator& operator++()  { // prefix
            m_Item = m_Item->m_Next;
            return (*this); 
        }
        Iterator operator++(int) { // postfix
            Iterator saved_this = *this;
            m_Item = m_Item->m_Next;
            return saved_this;
        }
        Iterator& operator--() { // prefix
            m_Item = m_Item->m_Prev;
            return (*this); 
        }
        Iterator operator--(int) { // postfix
            Iterator saved_this = *this;
            m_Item = m_Item->m_Prev;
            return saved_this;
        }
        operator bool() const {
            return m_Item != NULL;
        }
        bool operator==(const Iterator& other) const {
            return m_Item == other.m_Item;
        }
        bool operator!=(const Iterator& other) const {
            return m_Item != other.m_Item;
        }
        void operator=(const Iterator& other) {
            m_Item = other.m_Item;
        }
        void operator=(Item* item) {
            m_Item = item;
        }

    private:
        Item* m_Item;

        // friends
        friend class NPT_List<T>;
    };

    // methods
                 NPT_List<T>();
                 NPT_List<T>(const NPT_List<T>& list);
                ~NPT_List<T>();
    NPT_Result   Add(const T& data);
    NPT_Result   Insert(const Iterator where, const T& data);
    NPT_Result   Remove(const T& data, bool all=false);
    NPT_Result   Erase(const Iterator position);
    NPT_Result   PopHead(T& data);
    bool         Contains(const T& data) const;
    NPT_Result   Clear();
    NPT_Result   Get(NPT_Ordinal index, T& data) const;
    NPT_Result   Get(NPT_Ordinal index, T*& data) const;
    NPT_Cardinal GetItemCount() const { return m_ItemCount; }
    Iterator     GetFirstItem() const { return Iterator(m_Head); }
    Iterator     GetLastItem() const  { return Iterator(m_Tail); }
    Iterator     GetItem(NPT_Ordinal index) const;

    // list manipulation
    NPT_Result   Add(NPT_List<T>& list);
    NPT_Result   Remove(const NPT_List<T>& list, bool all=false);

    // item manipulation
    NPT_Result   Add(Item& item);
    NPT_Result   Detach(Item& item);
    NPT_Result   Insert(const Iterator where, Item& item);

    // list operations
    // keep these template members defined here because MSV6 does not let
    // us define them later
    template <typename X> 
    NPT_Result Apply(const X& function) const
    {                          
        Item* item = m_Head;
        while (item) {
            function(item->m_Data);
            item = item->m_Next;
        }

        return NPT_SUCCESS;
    }

    template <typename X, typename P> 
    NPT_Result ApplyUntil(const X& function, const P& predicate, bool* match = NULL) const
    {                          
        Item* item = m_Head;
        while (item) {
            NPT_Result return_value;
            if (predicate(function(item->m_Data), return_value)) {
                if (match) *match = true;
                return return_value;
            }
            item = item->m_Next;
        }

        if (match) *match = false;
        return NPT_SUCCESS;
    }

    template <typename P> 
    Iterator Find(const P& predicate, NPT_Ordinal n=0) const
    {
        Item* item = m_Head;
        while (item) {
            if (predicate(item->m_Data)) {
                if (n == 0) {
                    return Iterator(item);
                }
                --n;
            }
            item = item->m_Next;
        }

        return Iterator(NULL);
    }

    // operators
    void operator=(const NPT_List<T>& other);
    bool operator==(const NPT_List<T>& other) const;
    bool operator!=(const NPT_List<T>& other) const;

protected:
    // types
    class Item 
    {
    public:
        // methods
        Item(const T& data) : m_Next(0), m_Prev(0), m_Data(data) {}

        // members
        Item* m_Next;
        Item* m_Prev;
        T     m_Data;

        // friends
        //friend class NPT_List<T>;
        //friend class NPT_List<T>::Iterator;
    };

    // members
    NPT_Cardinal m_ItemCount;
    Item*        m_Head;
    Item*        m_Tail;
};

模板
类别列表
{
受保护的：
类别项目；
公众：
//类型
T型元件；
类迭代器{
公众：
迭代器（）：m_项（NULL）{}
显式迭代器（Item*Item）：m_Item（Item）{}
迭代器（constiterator©）：m_项（copy.m_项）{}
运算符*（）常量{return m_Item->m_Data；}
T*运算符->（）常量{return&m_Item->m_Data；}
迭代器和运算符++（）{//前缀
m_Item=m_Item->m_Next；
返回（*本条）；
}
迭代器运算符++（int）{//后缀
迭代器保存了_this=*this；
m_Item=m_Item->m_Next；
返回保存的文件；
}
迭代器和运算符--（）{//前缀
m_Item=m_Item->m_Prev；
返回（*本条）；
}
迭代器运算符--（int）{//后缀
迭代器保存了_this=*this；
m_Item=m_Item->m_Prev；
返回保存的文件；
}
运算符bool（）常量{
返回m_项！=NULL；
}
布尔运算符==（常量迭代器和其他）常量{
返回m_项==其他m_项；
}
布尔运算符！=（常量迭代器和其他）常量{
返回m_项目！=其他m_项目；
}
void运算符=（常量迭代器和其他）{
m_项目=其他m_项目；
}
无效运算符=（项*项）{
m_项目=项目；
}
私人：
项目*m_项目；
//朋友
好友类NPT_列表；
};
//方法
NPT_列表（）；
不扩散核武器清单（常数不扩散核武器清单和清单）；
~NPT_List（）；
NPT_结果添加（常数和数据）；
NPT_结果插入（常量迭代器，其中常量T和数据）；
NPT_结果删除（常数T和数据，布尔值全部=假）；
NPT_结果擦除（常量迭代器位置）；
NPT_结果PopHead（T&data）；
布尔包含（常数T和数据）常数；
NPT_结果清晰（）；
NPT_结果获取（NPT_顺序索引、T和数据）常数；
NPT_结果获取（NPT_顺序索引，T*&数据）常数；
NPT_基数GetItemCount（）常量{return m_ItemCount；}
迭代器GetFirstItem（）常量{返回迭代器（m_Head）；}
迭代器GetLastItem（）常量{返回迭代器（m_Tail）；}
迭代器GetItem（NPT_序数索引）常量；
//列表操作
NPT_结果添加（NPT_列表和列表）；
NPT_结果删除（常数NPT_列表和列表，布尔全部=假）；
//项目操纵
NPT_结果添加（项目和项目）；
NPT_结果分离（项目和项目）；
NPT_结果插入（常量迭代器，其中，项和项）；
//列表操作
//保持在此处定义这些模板成员，因为MSV6不允许
//我们以后再定义它们
模板
NPT_结果应用（常数X和函数）常数
{                          
项目*项目=m_头；
while（项目）{
功能（项目->m_数据）；
项目=项目->m_下一步；
}
回归成功；
}
模板
NPT_结果ApplyUntil（常量X&函数，常量P&谓词，bool*match=NULL）常量
{                          
项目*项目=m_头；
while（项目）{
NPT_结果返回_值；
if（谓词（函数（项->m_数据），返回_值））{
如果（匹配）*匹配=真；
返回_值；
}
项目=项目->m_下一步；
}
如果（匹配）*匹配=假；
回归成功；
}
模板
迭代器查找（常量P&谓词，n=0）常量
{
项目*项目=m_头；
while（项目）{
if（谓词（项->m_数据））{
如果（n==0）{
返回迭代器（item）；
}
--n；
}
项目=项目->m_下一步；
}
返回迭代器（NULL）；
}
//操作员
void运算符=（常量NPT_列表和其他）；
布尔运算符==（常量NPT_列表和其他）常量；
布尔运算符！=（常数NPT_列表和其他）常数；
受保护的：
//类型
类项目
{
公众：
//方法
项目（常数和数据）：m_Next（0）、m_Prev（0）、m_data（数据）{}
//成员
项目*m_下一步；
项目*m_-Prev；
T m_数据；
//朋友
//好友类NPT_列表；
//朋友类NPT_列表：：迭代器；
};
//成员
NPT_基数m_ItemCount；
项目*m_头；
项目*m_Tail；
};

我需要调用Detach方法，以避免在列表超出范围时释放列表中的元素（我看到析构函数删除了所有元素）。 我的问题是：我如何调用它？无法创建项的实例，因为类项受保护。那么，这个列表应该如何工作呢？ 如果有必要，我当然可以修改列表，但我真的很感兴趣，它是如何工作，因为我正在努力学习C++，所以我想理解。

---

非常感谢您的帮助

您不能从NPT_列表继承，然后将项目升级为公共项目吗

class FooList : public NPT_List<Foo>
{
  public:
    class Item;

  ...
} 

class傻瓜：公共NPT\u列表
{
公众：
类别项目；
...
} 

类的接口不正确<代码>添加、

分离

和

插入

应采用

T&

参数，而不是

项&

<代码>分离还需要一个迭代器参数来指示要分离的元素

Edit:正如其他人指出的那样，已经有

Add

和

Insert

方法采用

const&

参数，因此这些其他方法可能都是为了得到保护。小虫子。让您感到困惑的是，缺少使用

T&

的

Detach

方法。需要将其添加为新的met

NPT_Result   Detach(const Iterator where, T& data);

NPT_Result   Add(const T& data);
NPT_Result   Insert(const Iterator where, const T& data);
NPT_Result   Erase(const Iterator position);