[C++] list #3

 

#include <iostream>
using namespace std;
#include <vector>
#include <list>

template<typename T>
class Node
{
public:
    Node() : _next(nullptr), _prev(nullptr), _data(T())
    {

    }

    Node(const T& value) : _next(nullptr), _prev(nullptr), _data(value)
    {

    }

public:
    Node*   _next;
    Node*   _prev;
    T       _data;
};

template<typename T>
class Iterator // Node pointer를 내부적으로 들고있는 역할
{
public:

    Iterator() : _node(nullptr)
    {

    }

    Iterator(Node<T>* node) : _node(node)
    {

    }

    // 자기 자신의 class 내부에서는 자동으로 template 타입으로 인식하기 때문에 <T> 생략 가능
    // ++it
    Iterator& operator++()
    {
        _node = _node->_next;
        return *this;
    }

    // it++
    Iterator operator++(int)
    {
        Iterator<T> temp = *this;
        _node = _node->_next;
        return temp;
    }

    // --it
    Iterator& operator--()
    {
        _node = _node->_prev;
        return *this;
    }

    // it--
    Iterator operator--(int)
    {
        Iterator<T> temp = *this;
        _node = _node->_prev;
        return temp;
    }

    T& operator*()
    {
        return _node->_data;
    }

    bool operator==(const Iterator& right)
    {
        return _node == right._node;
    }

    bool operator!=(const Iterator& right)
    {
        return _node != right._node;
    }

public:
    Node<T>* _node;
};

// <-> [header] <->
// [1] <-> [2] <-> [3] <-> [4] <-> [header] <->
template<typename T>
class List
{
public:
    List() : _size(0)
    {
        _header = new Node<T>();
        _header->_next = _header;
        _header->_prev = _header;
    }

    ~List()
    {
        while (_size > 0)
            pop_back();

        delete _header;
    }

    void push_back(const T& value)
    {
        AddNode(_header, value);
    }

    // before : [1] <-> [2] <-> [3] <-> [4] <-> [header] <->
    // after  : [1] <-> [2] <-> [3] <-> [header] <->
    void pop_back()
    {
        RemoveNode(_header->_prev);
    }

    // [node] <-> [ header ] <->
    // before : [1] <-> [2] <-> [before] <-> [4] <-> [header] <->
    // after  : [1] <-> [prevNode] <-> [node] <-> [before] <-> [4] <-> [header] <->
    Node<T>* AddNode(Node<T>* before, const T& value)
    {
        Node<T>* node = new Node<T>(value);

        Node<T>* prevNode = before->_prev;
        prevNode->_next = node;
        node->_prev = prevNode;

        node->_next = before;
        before->_prev = node;

        _size++;

        return node;
    }

    // before : [1] <-> [prevNode] <-> [node] <-> [nextNode] <-> [header] <->
    // after  : [1] <-> [prevNode] <-> [nextNode] <-> [header] <->
    Node<T>* RemoveNode(Node<T>* node)
    {
        Node<T>* prevNode = node->_prev;
        Node<T>* nextNode = node->_next;

        prevNode->_next = nextNode;
        nextNode->_prev = prevNode;
        delete node;

        _size--;

        return nextNode;
    }

    int size() { return _size; }

public:

    typedef Iterator<T> iterator;

    iterator begin() { return iterator(_header->_next); }
    iterator end() { return iterator(_header); }

    iterator insert(iterator it, const T& value)
    {
        Node<T>*  node = AddNode(it._node, value);
        return iterator(node);
    }

    iterator erase(iterator it)
    {
        Node<T>* node = RemoveNode(it._node);
        return iterator(node);
    }

public:
    Node<T>* _header;
    int _size;
};

int main()
{
    List<int> li;

    List<int>::iterator eraseIt;

    for (int i = 0; i < 10; i++)
    {
        if (i == 5)
        {
            eraseIt = li.insert(li.end(), i);
        }
        else
        {
            li.push_back(i);
        }
    }

    li.pop_back();
    li.erase(eraseIt);

    for (List<int>::iterator it = li.begin(); it != li.end(); ++it)
    {
        cout << (*it) << endl;
    }

    return 0;
}

---

https://www.inflearn.com/course/%EC%96%B8%EB%A6%AC%EC%96%BC-3d-mmorpg-1/dashboard

[C++과 언리얼로 만드는 MMORPG 게임 개발 시리즈] Part1: C++ 프로그래밍 입문 - 인프런 | 강의

 

C++ 카테고리의 글은 인프런 Rookiss님의 강의를 공부하며 정리하는 내용입니다.

이미 알고 있는 내용도 다시 정리 되어있을 수 있습니다.

 

모든 글은 제가 공부하기 위해 작성합니다.