별빛의 낙하지

#include <iostream>

#include <xutility>

#include <algorithm>

#include "Node.hpp"

#include "ListIterator.hpp"

#include "List.hpp"

using namespace STD; // 내가 만든 STL의 요소

int main()

{

List<> s; // Single Linked List

List<int, DNode<int>> d; // Double linked List

s.push_back(10);

s.push_back(12);

d.push_back(13);

d.push_back(14);

std::for_each( s.begin(), s.end(), [](int a) { std::cout << a << std::endl; } );

std::for_each( d.begin(), d.end(), [](int a) { std::cout << a << std::endl; } );

}

#include <xutility> // bidirectional_iterator_tag

namespace STD {

template<class C >

class ListIterator

{

public:

typedef typename C::elem_type elem_type; // 요소 타입

typedef typename C::node_type node_type;

typedef typename C::node_pointer_type node_pointer_type;

typedef typename C::iterator iterator;

typedef typename C::value_type value_type;

typedef std::bidirectional_iterator_tag iterator_category;

typedef typename C::difference_type difference_type;

typedef typename C::pointer pointer;

typedef typename C::reference reference;

ListIterator(node_type* node) {

_ptr = node;

}

bool operator!=(iterator& rhs) {

return (this->_ptr) != rhs._ptr;

}

bool operator==(iterator& rhs) {

return (this->_ptr) == rhs._ptr;

}

elem_type operator*() {

return (_ptr->_data);

}

node_type* operator++() {

return _ptr = _ptr->next;

}

node_type* operator++(int c) {

return _ptr = _ptr->next;

}

private:

node_type* _ptr;

};

}

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;
}

/*
	Move Constructor( 이동 연산자 )

	c++0x 에는 기존의 대입연산자에 이어서, 이동 연산자도 추가가 되었다.

*/

#include 

class MoveClass
{
public:
	// Default Constructor
	MoveClass() {
		std::cout << "Default Constructor Call" << std::endl;
	}
	
	// Copy Operator
	void operator=(MoveClass& a) {
		std::cout << "Copy Operator Call" << std::endl;
	}

	
	// Move Operator
	void operator=(MoveClass&& a) {
		std::cout << "Move Operator Call" << std::endl;
	}
};


// 값이 복사되는 곳에서는 일반적으로 복사 생성자가 호출된다.
MoveClass foo(MoveClass& a)
{
	MoveClass local;
	return local;		// 값이 복사 되는데, 우선순위가 존재한다.
						// MoveClass(const MoveClass& a) 형태의 복사 생성자가 존재하고,
						// MoveClass(MoveClass&& a) 형태의 이동 생성자가 존재하면
						// 이동 생성자를 호출한다.
}

int main()
{
	MoveClass a;			// Default Constructor Call
	MoveClass b;
	a = b;					// Copy operator Call
	
	a = std::move(b);		// move Operator Call

}