MyList 双链表

#define ZB_MYLIST_
#ifdef ZB_MYLIST_
#include "debug.h"
#include <xstddef>

class AllocMyList
{
public:
AllocMyList(){}
~AllocMyList(){}
void* Allocator(size_t len) { return new char[len]; }
void Free(void *ptr, size_t len = 0) { delete[] ptr; }
void Swip(){}

template<class _Objty,
class... _Types>
void construct(_Objty *_Ptr, _Types&&... _Args)
{	// construct _Objty(_Types...) at _Ptr
::new ((void *)_Ptr) _Objty(_STD forward<_Types>(_Args)...);
}
};

template<typename T, typename Alloc = AllocMyList>
class MyList;

template<typename T>
struct Node
{
typedef T value_type;
typedef Node<T>* node_printer;
public:
Node()
:Data(), pPrev(nullptr), pNext(nullptr){}

Node(value_type data)
:Data(data), pPrev(nullptr), pNext(nullptr){}

Node(value_type data, node_printer prev, node_printer next)
:Data(data), pPrev(prev), pNext(next){}

bool operator==(Node& Rigth)
{
return (this->Data == Rigth.Data &&
this->pPrev == Rigth.pPrev &&
this->pNext == Rigth.pNext);
}

bool operator!=(Node& Right)
{
return !(*this == Right);
}

value_type Data;
node_printer pPrev;
node_printer pNext;
};

template<typename T>
class TIterator
{
typedef T value_type;
typedef Node<T> node_type;
typedef Node<T>* node_printer;
typedef MyList<T>* hash_printer;
typedef TIterator<T> iterator;
public:
TIterator():m_pNode(nullptr), m_pSelf(nullptr) {}

TIterator(node_printer pNode, hash_printer pList)
:m_pNode(pNode), m_pSelf(pList){}

node_printer GetNode()
{
return m_pNode;
}

value_type GetData()
{
return m_pNode->Data;
}

iterator& operator++()
{
ASSERT (m_pSelf->GetCount == 0 ||
m_pNode->pNext == nullptr);

this->m_pNode = this->m_pNode->pNext;
return *this;
}

iterator operator++(int)
{
TIterator temp = this;
++this;
return temp;
}

iterator& operator--()
{
ASSERT(m_pSelf->size() == 0 ||
m_pNode->pNext == nullptr);

return *this;
}

iterator operator--(int)
{
iterator temp = this;
--this;
return temp;
}
bool operator==(TIterator& Right)
{
return (this->m_pNode == Right.m_pNode);
}

bool operator!=(TIterator& Right)
{
return !(*this == Right);
}
private:
node_printer m_pNode;
hash_printer m_pSelf;
};

template<typename T, typename Alloc = AllocMyList>
class MyList
{
typedef T value_type;
typedef T* value_printer;
typedef T& reference;
typedef Node<T> node_type;
typedef Node<T>* node_printer;
typedef TIterator<T> iterator;
typedef size_t size_type;
public:
MyList()
{
MyHead = Buy();
MySize = 0;
}

MyList(size_type nCount)
{

}

MyList(size_type nCount, value_type Val)
{
Construct_n(nCount, Val);
}

// 返回当前对象个数
size_type size() const { return (this->MySize); }
size_type max_size() const { return ((size_type)(-1) / sizeof(value_type)); }//*
// 提供访问函数
reference front(){ return (*begin()); }
reference back() { return (*(end() - 1)); }
// 获取几种迭代器
iterator begin() const
{
return iterator(this->MyHead->pNext, this);
}

iterator end() const
{
return iterator(this->MyHead, this);
}

protected:
static node_printer& Nextnode(node_printer pNode)
{
return ((node_printer&)pNode->pNext);
}

static node_printer& Prevnode(node_printer pNode)
{
return ((node_printer&)pNode->pPrev);
}

static reference Myval(node_printer pNode)
{
return ((reference)pNode->Data);
}

private:
void Construct_n(size_type nCount, value_type Val)
{
Insert_n(begin(), nCount, Val);
}

void Insert_n(iterator Where, size_type nCount, value_type Val)
{
size_type nSaveCount = nCount;
_TRY_BEGIN
for (; nCount > 0; --nCount)
{
Inser(Where, Val);
}
_CATCH_ALL
for (;nCount < nSaveCount; ++nCount)
{
iterator Before = Where;
uncheck_erase(--Before);
}
_RERAISE;
_CATCH_END
}

void uncheck_erase(iterator Where)
{
node_printer pNode = Where.GetNode();
this->Nextnode(this->Prevnode(pNode)) = this->Nextnode(pNode);
this->Prevnode(this->Nextnode(pNode)) = this->Prevnode(pNode);
this->MySize--;
}

void Inser(iterator Where, value_type Val)
{
node_printer pNode = Where.GetNode();
node_printer new_node = BuyNode(Prevnode(pNode), pNode, Val);
IncSize(1);
this->Prevnode(pNode) = new_node;
this->Nextnode(this->Prevnode(new_node)) = new_node;
}

Alloc& Getal()
{
return (this->alloc);
}

Alloc& Getal() const
{
return (this->alloc);
}

node_printer BuyNode(node_printer prev, node_printer next, value_type data)
{
node_printer temp = static_cast<node_type*>(this->Getal().Allocator(sizeof(data)));
if (*next == node_type())
{
prev = temp;
next = temp;
}
_TRY_BEGIN
this->Getal().construct(std::addressof(Prevnode(temp)), prev);
this->Getal().construct(std::addressof(Nextnode(temp)), next);
_CATCH_ALL
this->Getal().Free(temp);
_RERAISE;
_CATCH_END
return temp;
}

void IncSize(size_type nCount)
{
if (max_size() - this->MySize - 1 < nCount)
ASSERT("Mylist<T> is too long");
this->MySize += nCount;
}
private:
Alloc alloc;
node_printer MyHead;
size_type MySize;
};

#endif//ZB_MYLIST_