별빛의 낙하지

namespace STD {

template<class C> class ListIterator; // LIstIterator에 대한 전방 선언

template<typename T> class Node; // Node에 대한 전방 선언

//template<typename T> class DNode; // DNode에 대한 전방 선언

template<typename T=int, class NODE=Node<T> >

class List

{

public:

typedef T elem_type;

typedef T* elem_pointer_type;

typedef NODE node_type;

typedef NODE* node_pointer_type;

typedef List<T,NODE> _THIS;

typedef ListIterator<_THIS> iterator;

// STL required

typedef T value_type;

typedef unsigned int difference_type;

typedef T* pointer;

typedef T& reference;

iterator begin() {

return ListIterator<_THIS>(_head->next);

}

iterator end() {

return ListIterator<_THIS>(_tail);

}

List() { 

_head = new NODE(0);

_tail = new NODE(0);

_tail->next = NULL;

_head->next = _tail;

_lastNode = _head;

}

void push_back(T element) {

NODE* elemNode = new NODE(element);

elemNode->next = _tail;

_lastNode->push_back( elemNode );

_lastNode = elemNode;

}

void push_back(NODE* next) {

_lastNode->push_back( next );

_lastNode = next;

}

private:

NODE* _head;

NODE* _tail;

NODE* _lastNode; // Last Node

};

}

STL의 요소를 만들어보기
만드는 과정은 시간 날때마다 업데이트...

namespace STD {

	// Single Linked List
	template<typename T>
	class Node
	{
	public:
		Node(T element) {
			_data = element;
			next = NULL;
		}

		void push_back(Node<T>* right) {
			right->next = this->next;
			this->next = right;
		}

		T operator*() {
			return _data;
		}

		T* operator++() {
			this = this->next;
		}

		T _data;
		Node<T>* next;
	};

	// Double Linked List
	template<typename T>
	class DNode
	{
	public:
		DNode(T element) {
			_data = element;
			next = NULL;
			prev = NULL;
		}

		void push_back(DNode<T>* right) {
			right->next = this->next;
			this->next = right;
			right->prev = this;
		}

		T operator*() {
			return _data;
		}

		T* operator++() {
			this = this->next;
		}

		T _data;
		DNode<T>* next;
		DNode<T>* prev;
	};
}

/*
	SingleLinkedList, DoubleLinkedList 둘 다 사용할 수 없을까?
	DoubleLinkedList를 만들기 위한 사전작업.
*/

#include <iostream>
template<typename T>
class Node
{
public:
	Node(T element) {
		_data = element;
		next = NULL;
	}
	
	void addToNext(Node<T>* right) {
		right->next = this->next;
		this->next = right;
	}

	T _data;
	Node* next;
};

// DoubleLinekd List
template<typename T>
class DNode
{
public:
	DNode(T element) {
		_data = element;
		next = NULL;
		prev = NULL;
	}
	
	void addToNext(DNode<T>* right) {
		right->next = this->next;
		this->next = right;
		right->prev = this;
	}

	T _data;
	DNode<T>* next;
	DNode<T>* prev;
};


template<typename T=int, template<typename L> class NODE=Node >
class List
{
public:
	typedef T value_type;

	List() { 
		_head = new NODE<T>(0);
		_tail = NULL;
		_lastNode = _head;
	}
	
	void addNext(T element) {
		NODE<T>* elemNode = new NODE<T>(element);
		_lastNode->addToNext( elemNode );
		_lastNode = elemNode;
	}

	void addNext(NODE<T>* next) {
		_lastNode->addToNext( next );
		_lastNode = next;
	}

private:
	NODE<T>* _head;
	NODE<T>* _tail;

	NODE<T>* _lastNode;			// Last Node 
};


int main()
{
	List<int, Node> s;		// Single Linked List
	List<int, DNode> d;		// Double LInked LIst

	s.addNext(new Node<int>(10) );
	s.addNext(new Node<int>(11) );
	s.addNext(12);
	s.addNext(13);

	d.addNext(10);
	d.addNext(11);
	d.addNext(12);
	d.addNext(13);
	
	std::cout << std::endl;
}