Связанный двусторонний список - C++ - Ответ 833054

#include <iostream>
using namespace std;
 
#ifndef MLIST_H
#define MLIST_H
//                      Class mListNode - node of my List Container class
template <class T>
class mListNode
{
public:
    mListNode();
    mListNode(const mListNode<T>&);
    ~mListNode();
    void setNext(mListNode* newNext) { next = newNext;};
    void setPrev(mListNode* newPrev) { prev = newPrev;};
    void setInfo(T* inf)             { info = inf;  };
    mListNode* getNext() const       { return next; };
    mListNode* getPrev() const       { return prev; };
    T* getInfo() const               { return info; };
    mListNode<T>& operator= (const mListNode<T>&);
protected:
    T* info;
    mListNode* prev;
    mListNode* next;
};
 
template <class T>
mListNode<T>::mListNode(const mListNode<T> & rhs)
{
    cout << "in COPY ctor of node\n";   
    info = rhs.info;
    prev = rhs.prev;
    next = rhs.next;
    cout << "exit COPY ctor of node\n";
}
template <class T>
mListNode<T>& mListNode<T>::operator =(const mListNode<T> &rhs)
{
    if (this == &rhs)
        return *this;
    delete info;
    delete prev;
    delete next;
    info = rhs.info;
    prev = rhs.prev;
    next = rhs.next;
    return *this;
}
template <class T>
mListNode<T>::mListNode():
info(0) , prev(0), next(0)
{
    //cout << "in ctor of node\n";
    //cout << "exit ctor of node\n";
}
 
template <class T>
mListNode<T>::~mListNode()
{
    cout << "info\n";
    delete info;
    info = NULL;
    cout << "prev\n";
    delete prev;
    prev = NULL;
    cout << "next\n";
    delete next;
    next = NULL;
}
 
 
//                      Class mList - my List Container
 
template <class T>
class mList
{
public:
    mList() { size = 0; head = 0;};
    mList(const mList<T>&);
    //~mList();
    void pushBack(T& inf);                      //добавляет информацию в конец списка
    void pushTop(T& inf);                       //добавляет информацию в начало списка
    mList<T>& operator=(const mList<T>&);
    T& operator[] (unsigned int num) const ;    //получение информации основываясь на номере в списке
    void clear();                               //отчистка списка
    void popFront();
    class exOutOfRange { };                     // oor exeption
protected:
    mListNode<T>* head;
    unsigned int size;
};
 
template <class T>
mList<T>::mList(const mList& rhs)
{
    head = rhs.head;
    size = rhs.size;
}
template <class T>
mList<T>& mList<T>::operator =(const mList<T> &rhs)
{
    if (this == &rhs)
        return *this;
    delete head;
    head = rhs.head;
    size = rhs.size;
}
 
template <class T>
T& mList<T>::operator[] (unsigned int num) const
{
    if (num > size - 1)
        throw exOutOfRange();
    mListNode<T>* tmp = head;
    for (unsigned int i = 0; i < num; i++)
    {
        tmp = tmp->getNext();
    }   
    T& info = *(tmp->getInfo());    
    return info;
}
 
template <class T>
void mList<T>::pushBack(T& inf)
{
    
    if (size == 0)
    {
        head = new mListNode<T>;
        head->setInfo(&inf);
        size++;
        return;
    }
    else
    {
        mListNode<T>* newNode = new mListNode<T>;
        mListNode<T>* current = head;
        mListNode<T>* next = 0;
        newNode->setInfo(&inf);
 
#define ever ;;
        for(ever)
        {
            next = current->getNext();
            if (next == NULL) //следущего нету - сюда и ставим
            {
                newNode->setPrev(current);
                newNode->setNext(NULL);
                current->setNext(newNode);
                break;
            }
            else //идем дальше
                current = next;
        }
 
    }
}
 
template <class T>
void mList<T>::pushTop(T& inf)
{
    if (head == NULL)
    {
        head = new mListNode<T>;
        head->setInfo(&inf);
        head->setPrev(NULL);
        head->setNext(NULL);
        size++;
        return;
    }
    else
    {
        mListNode<T>* newNode = new mListNode<T>;
        newNode->setInfo(&inf);
        newNode->setNext(head);
        newNode->setPrev(NULL);
        head->setPrev(newNode);
 
        head = newNode;
        size++;
    }
}
 
template <class T>
void mList<T>::clear()
{
    if (size == 0)
        return;
    while (size != 0)
    {
        popFront();
    }
 
}
template <class T>
void mList<T>::popFront()
{
    if (size == 0)
        return;
    mListNode<T>* tmp = head;
    head = head->getNext();
    delete tmp;
    size--;
    head->setPrev(NULL);
 
}
#endif