별빛의 낙하지

#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

}

/*
	Move Constructor( 이동 생성자 )

	c++0x 에는 r-value reference의 도입으로 인해서 Move Constructor가 생겼다.
	이동 생성자의 특징은 복사 대상의 데이터를 지우는 소유권 이전 방식이다.

	기존에 있던 reference는 그래서 이름이 l-value reference 로 불린다.
	l-value 와 r-value 의 차이는 대입식에서 왼쪽에 오느냐, 오른쪽에 오느냐의 차이인데
	
	간단히 말해서 l-value 는 변수라고 보면 되고, r-value는 상수라고 보면 된다.
	기존에 l-value reference는 l-value들만, 즉 변수들만 가리킬 수 있는 반면에
	r-value reference는 r-value 들만, 즉 상수들을 가리킬 수 있다.
	
	int b = 3;
	int& a = b;
	int& c = 3; // error
	
	int&& d = a; // error
	int&& d = 3; // ok.

	r-value reference가 사실 그냥 보기에는 이동 생성자와 전혀 무관해 보이는데, 이것은 기존에
	복사 생성자로 표현하기 어색했던, 소유권 이전방식을 적절히 표현하기에 적합하다.

	무슨 말이냐면,  기존에 auto_ptr 과 같은 소유권 이전의 스마트 포인터들은 값을 이동시키고 싶어하지만,
	적절한 표현이 없어서, const를 제외시킨 아래와 같은 방식으로 구현을 했었다.

	auto_ptr(auto_ptr& a)
	
	문제는 이것이 복사하려는 것인지, 이동하려는 것인지에 대한 명확한 지표가 되기 힘들다는 것.
	이 문제를 해결한 것이 r-value reference(&&)의 등장이다.
r
*/

#include 

class MoveClass
{
public:
	// Default Constructor
	MoveClass() {
		std::cout << "Default Constructor Call" << std::endl;
	}
	
	// Copy Constructor
	MoveClass(const MoveClass& a)	// 반드시 const로 해야 된다. 그렇지 않으면 Move Constructor가 제대로 호출되지 않는다.  
	{
		std::cout << "Copy Constructor Call" << std::endl;				

	}

	// Move Constructor
	MoveClass(MoveClass&& a)
	{
		std::cout << "Move Constructor 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

	foo(a);

	MoveClass b(a);					// Copy Consturctor call
	MoveClass b(std::move(a));		// Move Constructor call

}

C++은 함수 오버로딩을 지원하기 때문에 기존의 C스타일의 이름의 함수로는 함수오버로딩을 지원할 수 없다. 

따라서 함수 이름에 대한 데코레이션(decoration) 혹은 맹글링(mangling)이 필요하다.

(데코레이션과 맹글링은 이름을 꾸미는 것, 섞는 것이라는 그런 의미다.)

*네임 맹글링 자체가 함수를 구분해주기 위한 용도로써라고 이해하기 되면 약간 거시기 하다.

정확히 이야기하면 C에서도 함수를 부를때 네임 맹글링을 한다. 

"_"를 함수 이름에 붙이는데,  C++기준으로 보면 이건 네임맹글링 수준이 매우 미미하다.

여기서는 함수 오버로딩을 지원하기 위한 측면에서 살펴보겠다.

name mangling, 혹은 name decoration을 하기 위한 것은 컴파일러가 결정하게 되는데,

일반적으로 함수의 파라미터로 함수 지원한다고 생각했었으나 실제 테스트 해보니 그렇지 않았다.

VC++ Compiler에서 반환값도 네임 맹글링에 포함된다.

예를 들어서 아래는 반환값 test2(void) 의 함수 시그니처이다.

C++ 관련 책을 보면 아래와 같은 코드에서 C++ 컴파일러가 클래스 내에서 생성자가 정의되어 있지 않을 경우, 기본 생성자(default constructor)를 삽입한다고 알려져 있다.

하지만 실제로는 컴파일러 구현체에 따라서 달라지겠지만, 내가 현재 주로 쓰고 있는 VC++에서는 그러한 뻘짓(?)을 하지 않는다.

class Ref
{
public:
	int a;
	int b;

};

int main()
{
	Ref a;
	a.a = 12;
	a.b = 13;
	Ref b = a;

}

실제 어셈블리로 변환된 코드는 아래와 같다.

놀랍지 않은가?  보시다시피 기본 생성자를 부를꺼라고 예상했지만, 실제로는 그러한 코드는 없다.

또한 디폴트 복사 생성자도 존재하지 않음을 알 수 있다.

만약 생성자가 존재하는 상태에서 기본 복사 생성자도 존재할까?

아래의 코드를 디스어셈블 해보았다.

class Ref
{
public:
	int a;
	int b;
	Ref(int a, int b) { cout << "1 "; }
};

int main()
{
	Ref a(1, 2);
	Ref b = a;
}

그 결과 아래와 같은 코드로 변환이 되었음을 알 수 있었다.

즉 사용자가 정의한 생성자는 호출되었지만, 복사 생성자는 역시 존재하지 않음을 알 수 있다.

객체의 동적 할당인 경우는 어떻게 될까?

아래의 코드를 보자

class Ref
{
public:
//	Ref(){ cout << "constructor call" << endl; }
//	~Ref() { cout << "destructor call" << endl; }

};

int main()
{
	Ref* p = new Ref;

	delete p;


}

즉 여전히 기본 생성자는 찾아 볼 수가 없다. 메모리 할당, 해제와 관련된 함수 호출이 있을 뿐이다.  여기서 재미있는 것은 소멸자 또한 없다는 사실이다.

비교를 하기 위해서 아래는 명시적으로 생성자를 지정한 경우의 동적할당 어셈코드이다.

class Ref
{
public:
	Ref(){ cout << "constructor call" << endl; }
	~Ref() { cout << "destructor call" << endl; }

};

int main()
{
	Ref* p = new Ref;

	delete p;


}