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

假设我使用的是一个非标准的链表类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个不同的整数，这样就创建了适当的#个新节点。

现在，我如何遍历这个列表，以便找到所有这些int的和？这可能吗？或者我目前的功能阻止了这一点吗？我必须为我的List类实现某种迭代器？

现在我知道我可以保留一个外部变量，每次我调用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! nn!"<<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! nn";
}
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);
}