list(static allocation)

#include<iostream>
 
using namespace std;
 
class ListNode {
public:
    int value;
    ListNode* pPrev, * pNext;
 
    ListNode() {
        value = -1;
        pPrev = 0;
        pNext = 0;
    }
};
 
 
ListNode listNodePool[100000];
int listNodePoolIndex;
ListNode* NewListNode() {
    int tmp = listNodePoolIndex;
    listNodePoolIndex++;
 
    listNodePool[tmp].value = -1;
    listNodePool[tmp].pPrev = nullptr;
    listNodePool[tmp].pNext = nullptr;
 
    return &listNodePool[tmp];
}
 
 
class List {
public:
    ListNode* front, * back;
 
    List() {
        _size = 0;
        front = NewListNode();
        back = NewListNode();
 
        front->pNext = back;
        back->pPrev = front;
    }
 
    void PushBack(int value) {
        ListNode* newNode = NewListNode();
        newNode->value = value;
 
        ListNode* lastNode = back->pPrev;
        lastNode->pNext = newNode;
        back->pPrev = newNode;
 
        newNode->pPrev = lastNode;
        newNode->pNext = back;
        _size++;
    }
 
    void PushFront(int value) {
        ListNode* newNode = NewListNode();
        newNode->value = value;
 
        ListNode* firstNode = front->pNext;
        firstNode->pPrev = newNode;
        front->pNext = newNode;
 
        newNode->pPrev = front;
        newNode->pNext = firstNode;
        _size++;
    }
 
    //prevNode 뒤쪽에 newValue를 추가한다.
    void Insert(ListNode* prevNode, int newValue) {
        ListNode* nextNode = prevNode->pNext;
        ListNode* newNode = NewListNode();
 
        prevNode->pNext = newNode;
        nextNode->pPrev = newNode;
 
        newNode->pPrev = prevNode;
        newNode->pNext = nextNode;
 
        _size++;
    }
 
    ListNode* Erase(ListNode* deleteNode) {
        ListNode* prevNode = deleteNode->pPrev;
        ListNode* nextNode = deleteNode->pNext;
 
        prevNode->pNext = nextNode;
        nextNode->pPrev = prevNode;
 
        //delete deleteNode;
        _size--;
 
        return nextNode;
    }
 
 
    void Clear() {
        /*
        if(_size >= 1) {
            ListNode* it = front->pNext->pNext;
            for (; it != back; it = it->pNext)
                delete it->pPrev;
            
            delete it->pPrev;
        }
        */
        front->pNext = back;
        back->pPrev = front;
 
        _size = 0;
    }
 
    int Size() {
        return _size;
    }
 
    ~List() {
        Clear();
        //delete front;
        //delete back;
    }
 
 
 
private:
    int _size;
 
};
 
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    
    List list;
    for (int i = 10; i < 20; i++)
        list.PushBack(i);
 
    for (int i = 9; i >= 0; i--)
        list.PushFront(i);
 
    for (ListNode* it = list.front->pNext; it != list.back; it = it->pNext)
        cout << it->value << " ";
 
 
    return 0;
}