0

私は二重リンクリストクラスに取り組んでいます。次の要素へのポインターと前の要素へのポインター、およびデータ セクションを含む Node クラスを実装しました (テンプレート パラメーター 'Type' で定義された型を使用)。

最初は、これを 2 つのクラスとして実装しました。1 つのクラスは Node を定義し、もう 1 つのクラスはノードのリンク リスト (rList) を定義しました。ノードはリスト内に隠され、rlist によってのみ管理される必要があるため、Node クラス テンプレートを rList のプライベート メンバーとして含めたいと考えました。

Node クラスには、データ セクションを初期化し、ポインターを null に設定するコンストラクターしかありません。

Node クラスを rList クラスのプライベート セクションに配置しようとしましたが、編成が正しくないようです。構文エラーに悩まされます。以下は私の現在の実装です。

template<typename Type>
class Node
{
    Node* next;
    Node* prev;

public:
    Node(Type);
    template<typename Type> friend class rList;
    Type data;
};

template<typename Type>
Node<Type>::Node(Type d):data(d), next(0), prev(0)
{}


template<typename Type>
class rList
{
private:
    Node<Type>* head;
    Node<Type>* tail;
    int size;

public:

    rList<Type>();
    ~rList();
    void push_front(const Type&);
    void push_back(const Type&);
    void insert(Node<Type>*, const Type&); //needs to be changed after merge
    void erase(Node<Type>*); //needs to be changed after merge
    void clear();
};

template<typename Type>
rList<Type>::rList():head(0), tail(0), size(0)
{}


template<typename Type>
rList<Type>::~rList()
{
    clear();
}


template<typename Type>
void rList<Type>::clear()
{
    while(head != 0)
    {
        Node<Type>* nextNode = head->next;
        delete head;
        head = nextNode;
    }
}


template<typename Type>
void rList<Type>::push_front(const Type& data)
{
    Node<Type>* newOne = new Node<Type>(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else
    {
        newOne->next = head;
        head = newOne;
    }
    size++;
}


template<typename Type>
void rList<Type>::push_back(const Type& data)
{
    Node<Type>* newOne = new Node<Type>(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else
    {
        tail->next = newOne;
        newOne->prev = tail; 
        tail = newOne;
    }
    size++;
}


template<typename Type>
void rList<Type>::insert(Node<Type>* itr, const Type& data)
{
    Node<Type>* newOne = new Node<Type>(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else 
    {   
        newOne->next = itr;
        (itr->prev)->next = newOne;
        newOne->prev = itr->prev;
        itr->prev = newOne;
    }
    size++;
}


template<typename Type>
void rList<Type>::erase(Node<Type>* itr)
{
    if(itr == tail)
    {
        tail = itr->prev;
        tail->next = 0;
        delete itr;
    }

    else if(itr == head)
    {
        head = itr->next;
        head->prev = 0;
        delete itr;
    }

    else
    {
        (itr->prev)->next = itr->next;
        (itr->next)->prev = itr->prev;
        delete itr;
    }
    size--;
}


template<typename Type>
Node<Type>* rList<Type>::begin()
{
    return head;
}


template<typename Type>
Node<Type>* rList<Type>::end()
{
    return tail;
}


template<typename Type>
Node<Type>* rList<Type>::nextElem(Node<Type>* node)
{
    return node->next;
}

Node* は rList クラスの外で定義できないため、これによりいくつかのことが壊れることを認識しています。rList 内の Nodes にアクセスするための iterator クラスを使用して、後でこれを変更する予定です。しかし最初に、このような配置でテンプレートとメンバー関数の定義をどのように整理すればよいでしょうか? 以下は私の試みを示しています：

template<typename Type>
class rList //rList class template
{
private:
    template<typename Type>
    class Node //Node class template
    {
        Node* next;
        Node* prev;

    public:
        Type data; //can be any POD type or class/struct
        Node(Type);
        template<typename Type> friend class rList; //so rList can access private Node pointers
    };
    Node<Type>* head;
    Node<Type>* tail;
    int size;

public:
    rList<Type>();
    ~rList();
    void push_front(const Type&);
    void push_back(const Type&);
    void insert(Node<Type>*, const Type&);
    void erase(Node<Type>*);
    clear();
};

template<typename Type>
rList<Type>::rList():head(0), tail(0), size(0)
{}


template<typename Type>
rList<Type>::~rList()
{
    clear();
}

template<typename Type>
void rList<Type>::clear()
{
    while(head != 0)
    {
        Node<Type>* nextNode = head->next;
        delete head;
        head = nextNode;
    }
}

template<typename Type>
void rList<Type>::push_front(const Type& data)
{
    Node<Type>* newOne = new Node<Type>(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else
    {
        newOne->next = head;
        head = newOne;
    }
    size++;
}

template<typename Type>
void rList<Type>::push_back(const Type& data)
{
    Node<Type>* newOne = new Node<Type>(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else
    {
        tail->next = newOne;
        newOne->prev = tail; 
        tail = newOne;
    }
    size++;
}

template<typename Type>
void rList<Type>::insert(Node<Type>* itr, const Type& data)
{
    Node<Type>* newOne = new Node<Type>(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else 
    {   
        newOne->next = itr;
        (itr->prev)->next = newOne;
        newOne->prev = itr->prev;
        itr->prev = newOne;
    }
    size++;
}


template<typename Type>
void rList<Type>::erase(Node<Type>* itr)
{
    if(itr == tail)
    {
        tail = itr->prev;
        tail->next = 0;
        delete itr;
    }

    else if(itr == head)
    {
        head = itr->next;
        head->prev = 0;
        delete itr;
    }

    else
    {
        (itr->prev)->next = itr->next;
        (itr->next)->prev = itr->prev;
        delete itr;
    }
    size--;
}


//constructor for Node
template<typename Type>
rList<Type>::Node<Type>::Node(Type d):data(d), next(0), prev(0)
{}

ご意見をお待ちしております。

* 更新コード * 以下のコードは、提案に基づいて変更されました。機能しており、適切なメンバーを隠しているようです。気づいた改善点をコメントしてください！再度、感謝します！！

template<typename Type>
class rList
{
private:

    class Node
    {
        Node* next;
        Node* prev;

    public:
        Type data;
        Node(Type d);
        template<typename Type> friend class rList;
    };

    Node* head;
    Node* tail;
    int size;

public:
    rList<Type>();
    ~rList();
    void push_front(const Type&);
    void push_back(const Type&);
    void insert(Node*, const Type&);
    void erase(Node*);
    void clear();
};

template<typename Type>
rList<Type>::rList():head(0), tail(0), size(0)
{}


template<typename Type>
rList<Type>::~rList()
{
    clear();
}

template<typename Type>
void rList<Type>::clear()
{
    while(head != 0)
    {
        Node* nextNode = head->next;
        delete head;
        head = nextNode;
    }
}

template<typename Type>
void rList<Type>::push_front(const Type& data)
{
    Node* newOne = new Node(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else
    {
        newOne->next = head;
        head = newOne;
    }
    size++;
}

template<typename Type>
void rList<Type>::push_back(const Type& data)
{
    Node* newOne = new Node(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else
    {
        tail->next = newOne;
        newOne->prev = tail; 
        tail = newOne;
    }
    size++;
}

template<typename Type>
void rList<Type>::insert(Node* itr, const Type& data)
{
    Node* newOne = new Node(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else 
    {   
        newOne->next = itr;
        (itr->prev)->next = newOne;
        newOne->prev = itr->prev;
        itr->prev = newOne;
    }
    size++;
}


template<typename Type>
void rList<Type>::erase(Node* itr)
{
    if(itr == tail)
    {
        tail = itr->prev;
        tail->next = 0;
        delete itr;
    }

    else if(itr == head)
    {
        head = itr->next;
        head->prev = 0;
        delete itr;
    }

    else
    {
        (itr->prev)->next = itr->next;
        (itr->next)->prev = itr->prev;
        delete itr;
    }
    size--;
}

template<typename Type>
rList<Type>::Node::Node(Type d):data(d), next(0), prev(0)
{}
4

0 に答える 0