0 
template<typename NODETYPE>
const List<NODETYPE> &List<NODETYPE>::operator =(const List<NODETYPE> &right)
{
    if(&right !=this)
    //ListNode is another class I friended with my list class
    {

        ListNode<NODETYPE> *tempPtr = firstPtr;
        ListNode<NODETYPE> *rightPtr = right.firstPtr;

        if(firstPtr==lastPtr)
        {
            firstPtr = lastPtr = 0;
            delete tempPtr;

            while(rightPtr!=NULL)
            {
                insertAtBack(rightPtr->data);
                rightPtr=rightPtr->nextPtr;
            }
        }
        else
        {
            while(tempPtr!=NULL)
            {
                firstPtr = firstPtr->nextPtr;
                delete tempPtr;
                tempPtr = firstPtr;
            }
            while(rightPtr!=NULL)
            {
                insertAtBack(rightPtr->data);
                rightPtr=rightPtr->nextPtr;
            }
        }
    }
    return *this;
}
template<typename NODETYPE>
List<NODETYPE>& List<NODETYPE>::concatenate(const List<NODETYPE>&right)const
{
    ListNode<NODETYPE>*tempPtr = firstPtr;

我在这里使用了 new 运算符，因此当我返回它时不会调用对象的析构函数。我想创建一个由两个列表组成的全新 List 对象并将其返回给主函数，同时避免任何内存泄漏。

    List<NODETYPE>*newList = new List;


    while(tempPtr != NULL)
    {
        newList->insertAtBack(tempPtr->data);
        tempPtr = tempPtr->nextPtr;
    }
    tempPtr = right.firstPtr;

    while(tempPtr != NULL)
    {
        newList->insertAtBack(tempPtr->data);
        tempPtr = tempPtr->nextPtr;
    }
    return *newList;
}

如何在不造成内存泄漏的情况下返回 newlist 对象？

template< typename NODETYPE >

void List< NODETYPE >::insertAtBack( const NODETYPE &value )
{
   ListNode< NODETYPE > *newPtr = getNewNode( value ); // new node

   if ( isEmpty() ) // List is empty
      firstPtr = lastPtr = newPtr; // new list has only one node
   else // List is not empty
   {
      lastPtr->nextPtr = newPtr; // update previous last node
      lastPtr = newPtr; // new last node
   } // end else
} // end function insertAtBack

template< typename NODETYPE >
void List< NODETYPE >::insertAtPos( const NODETYPE & value, int pos)
{
    if (pos == 0)
        insertAtFront(value);
    else if (pos < 0)
        cerr << "Trying to insert at invalid list position: " << pos << endl;
    else {
        ListNode< NODETYPE > * ptr = firstPtr;
        for (int i=0; i<pos-1 && ptr != NULL; i++)
            ptr = ptr->nextPtr;
        if (ptr != NULL) {
            ListNode< NODETYPE > *newPtr = getNewNode( value ); // new node
            newPtr->nextPtr = ptr->nextPtr;
            ptr->nextPtr = newPtr;
        }
        else {
            cerr << "Trying to insert at invalid list position." << endl;
        }
    }
}
4

1 回答 1

1

如果有人忘记删除从连接返回的对象，则会出现内存泄漏问题。如果您将对列表的引用作为参数，您可以让他们分配列表，并且它将在他们的代码中适当地保留范围。

本质上不要在函数中分配内存，要求将其传递给函数。

List<NODETYPE>& List<NODETYPE>::concatenate(const List<NODETYPE> &right, List &newList) const

您仍然可以在最后返回对 newList 的引用，以便可以链接函数。

于 2013-04-17T03:32:07.003 回答