c++ - 在 C++ 中遍历非 STL 链表，可能吗？

Question

假设我使用的是非标准链表类 List.h。这个类是功能性的，模板化的，并且具有在前面添加/删除和在后面添加/删除、isEmpty() 等的典型功能。

此列表没有任何 begin() 和 end() 功能。另外，链表类是否必须包含迭代器功能？还是我可以在创建新列表时自行创建？

我习惯于使用 STL，所以我通常会使用以下代码:

typedef vector<OBJECT>::iterator QuoteIt;
for(QuoteIt i = deposits.begin(); i != deposits.end(); ++i)

无论如何，假设我创建了一个新的“列表”。

List<int>deposits;

甚至是对象列表

List<OBJECT>deposits;

假设我 addToBack() 20 个不同的整数，这样就创建了适当数量的新节点。

现在，我如何遍历这个列表以便找到所有这些整数的总和？这是可能的，还是我当前的功能会阻止这种情况？我必须为我的列表类实现某种迭代器吗？

现在我知道我可以保留一个外部变量，每次我调用 addToBack() 来跟踪我的总和。但是，我希望代码也与对象列表兼容。 (我希望能够在节点中搜索一个值，并最终在同一节点中检索另一个值)

我已经习惯使用 STL::list 并使用迭代器创建 for 循环，我真的不知道如何让它与其他类一起工作。

顺便说一句，这是 List() 的代码:

template<class NODETYPE>
class List{

public:
List();
~List();
void insertAtFront(const NODETYPE &);
void insertAtBack(const NODETYPE  &);
bool removeFromFront( NODETYPE &);
bool removeFromBack( NODETYPE &);
bool isEmpty() const;

private:
ListNode< NODETYPE > *firstPtr; //pointer to first node
ListNode< NODETYPE > *lastPtr;
//Function to allocate a new node
ListNode< NODETYPE > *getNewNode ( const NODETYPE &);

};
//default constructor
template <class NODETYPE>
List< NODETYPE > ::List()
:  firstPtr(0),
   lastPtr(0)
{
cout<<"Creating Nodes! \n\n!"<<endl;
}
//deconstructor
template <class NODETYPE>
List<NODETYPE>::~List(){
    if(!isEmpty() ){
        cout<<"Destroying nodes!"<<endl;
        ListNode<NODETYPE> *currentPtr=firstPtr;
        ListNode<NODETYPE> *tempPtr;

        while( currentPtr !=0){
            tempPtr = currentPtr;
            currentPtr=currentPtr->nextPtr;
            delete tempPtr;
        }
    }
cout<<"All nodes destroyed! \n\n";
}

template <class NODETYPE>
bool List <NODETYPE>::removeFromFront( NODETYPE & value){
if ( isEmpty() )
    return false;
else{
    ListNode<NODETYPE> *tempPtr = firstPtr;

    if (firstPtr== lastPtr)
        firstPtr=lastPtr = 0;
    else
        firstPtr=firstPtr->nextPtr;

    value = tempPtr->data;
    delete tempPtr;

    return true;
}    
}     
template <class NODETYPE>
bool List<NODETYPE>::removeFromBack(NODETYPE &value)
{
    if (isEmpty())
        return false;
    else{
        ListNode< NODETYPE> *tempPtr = lastPtr;
        if( firstPtr == lastPtr)
            firstPtr = lastPtr = 0;
        else{
            ListNode<NODETYPE> *currentPtr=firstPtr;

            //Finds second to last element
            while(currentPtr->nextPtr !=lastPtr)
                currentPtr=currentPtr->nextPtr;

            lastPtr = currentPtr;
            currentPtr->nextPtr=0;
        }

        value = tempPtr->data;
        delete tempPtr;

        return true;
    }
}

//Checks to see if list is empty
template< class NODETYPE>
bool List< NODETYPE >::isEmpty() const{
return firstPtr == 0;
}
//returns a pointer to newly created Node
template<class NODETYPE>
ListNode<NODETYPE> *List<NODETYPE>::getNewNode(const NODETYPE &value){
return new ListNode<NODETYPE>(value);
}

Answer 1

回应:

Now, how can I traverse this list so I can find a sum of all these ints? Is that possible, or does my current functionality prevent that? I would have to implement some sort of iterator to my List Class?

您需要实现一种方法来迭代您的列表，该方法不会(作为副作用)破坏您的列表。