完善list

list.cpp

@@ -1,54 +1,51 @@
 #include "list.h"
 
-// #pragma region list<T>::iterator
-template<typename T>
-list<T>::iterator::iterator(list_node* ptr) {
+#define HOLDER
+#define __TEMPLATE template<typename Type>
+#define TEMPLATE(rtype) __TEMPLATE rtype
+
+#define ADT List<Type>
+#define NODE ADT::Node
+#define ITERATOR ADT::iterator
+
+// #pragma region List<Type>::iterator
+TEMPLATE(HOLDER) ITERATOR::iterator(Node* ptr) {
 	_ptr = ptr;
 }
 
-template<typename T>
-typename::list<T>::iterator& list<T>::iterator::operator++() {
+TEMPLATE(typename ITERATOR&) ITERATOR::operator++() {
 	_ptr = _ptr->_next;
 	return *this;
 }
 
-template<typename T>
-typename::list<T>::iterator& list<T>::iterator::operator--() {
+TEMPLATE(typename ITERATOR&) ITERATOR::operator--() {
 	_ptr = _ptr->_prev;
 	return *this;
 }
 
-template<typename T>
-bool list<T>::iterator::operator== (const list<T>::iterator& it) {
+TEMPLATE(bool) ITERATOR::operator== (const ITERATOR& it) {
 	// TBD 其它信息比较
 	return _ptr == it._ptr;
 }
 
-template<typename T>
-bool list<T>::iterator::operator!= (const list<T>::iterator& it) {
+TEMPLATE(bool) ITERATOR::operator!= (const ITERATOR& it) {
 	return !(*this == it);
 }
 // #pragma endregion
 
-// #pragma region list<T>
-template<typename T>
-list<T>::list() : dummy(&dummy, &dummy) {};
+// #pragma region List<Type>
+TEMPLATE(HOLDER) ADT::List() : dummy(&dummy, &dummy) {};
 
-template<typename T>
-typename::list<T>::iterator list<T>::begin() { return list<T>::iterator(head->_next); }
+TEMPLATE(typename ITERATOR) ADT::begin() { return ADT::iterator(head->_next); }
 
-template<typename T>
-typename::list<T>::iterator list<T>::end() { return list<T>::iterator(head); }
+TEMPLATE(typename ITERATOR) ADT::end() { return ADT::iterator(head); }
 
-template<typename T>
-typename::list<T>::iterator list<T>::rbegin() { return list<T>::iterator(tail->_prev); }
+TEMPLATE(typename ITERATOR) ADT::rbegin() { return ADT::iterator(tail->_prev); }
 
-template<typename T>
-typename::list<T>::iterator list<T>::rend() { return list<T>::iterator(tail); }
+TEMPLATE(typename ITERATOR) ADT::rend() { return ADT::iterator(tail); }
 
-template<typename T>
-typename::list<T>::iterator& list<T>::operator[] (int index) {
-	list_node* curr = head;
+TEMPLATE(typename ITERATOR&) ADT::operator[] (int index) {
+	Node* curr = head;
 	for (; index >= 0; --index) {
 		if (curr == nullptr) {
 			return end();
@@ -58,33 +55,36 @@ typename::list<T>::iterator& list<T>::operator[] (int index) {
 	return iterator(curr);
 }
 
-template<typename T>
-typename::list<T>& list<T>::operator+= (const T& value) {
-	list_node* node = new list_node(value, tail->_prev, tail);
+TEMPLATE(ADT&) ADT::operator+= (Type& value) {
+	Node* node = new Node(value, tail->_prev, tail);
 	tail->_prev->_next = node;
 	tail->_prev = node;
 	return *this;
 }
-// #pragma endregion
-
-
-
-
-
-
-
-
-
-
-
-
-
 
+TEMPLATE(typename ITERATOR) ADT::append(Type& value) {
+	Node* node = new Node(value, tail->_prev, tail);
+	tail->_prev->_next = node;
+	tail->_prev = node;
+	return iterator(node);
+}
+// #pragma endregion
 
+#undef HOLDER
+#undef __TEMPLATE
+#undef TEMPLATE
+#undef ADT
+#undef NODE
+#undef ITERATOR
 
+// #define __DEBUG_LIST__ 
+#ifdef __DEBUG_LIST__
 
+#include <iostream>
+#include <string>
+#include <vector>
+#include <memory>
 
-#ifdef __DEBUG_LIST__
 struct Test {
 	int num;
 	std::string str;
@@ -95,15 +95,15 @@ struct Test {
 };
 
 int main() {
-	list<Test> l1;
+	List<Test> list;
 	for (int i = 0; i < 255; ++i) {
 		Test t;
 		t.str = std::to_string(i + 1);
 		t.num = i + 1;
-		l1 += t;
+		list += t;
 	}
 
-	for (auto item : l1) {
+	for (auto item : list) {
 		std::cout << "str:" << item.str << ". num:" << item.num << ". " << std::endl;
 	}
 	return 0;

list.h

@@ -1,45 +1,44 @@
-#ifndef __LIST_H__
-#define __LIST_H__
+#ifndef __L87_LIST_H__
+#define __L87_LIST_H__
 
-#include <iostream>
-#include <string>
-#include <vector>
-#include <memory>
-
-template<typename T>
-class list {
+template<typename Type>
+class List {
 public:
-	struct list_node {
-		T* _value;
-		list_node* _prev, * _next;
-		list_node() : _prev(nullptr), _next(nullptr) { _value = nullptr; }
-		list_node(list_node* prev, list_node* next) : _prev(prev), _next(next) { _value = nullptr; }
-		list_node(const T& value, list_node* prev = nullptr, list_node* next = nullptr) : _prev(prev), _next(next) { _value = new T(value); }
-		T& operator*() { return *_value; }
+	struct Node {
+		Type* _value;
+		Node* _prev, * _next;
+		Node() : _prev(nullptr), _next(nullptr) { _value = nullptr; }
+		Node(Node* prev, Node* next) : _prev(prev), _next(next) { _value = nullptr; }
+		Node(Type& value, Node* prev = nullptr, Node* next = nullptr) : _prev(prev), _next(next) { _value = new Type(value); }
+		Type& operator*() { return *_value; }
 	};
 
 	class iterator {
 	private:
-		list_node* _ptr;
+		Node* _ptr;
 		// TBD 其它信息
 	public:
-		iterator(list_node* ptr);
+		iterator(Node* ptr);
 		iterator& operator++();
 		iterator& operator--();
 		bool operator== (const iterator& it);
 		bool operator!= (const iterator& it);
-		T& operator*() { return **_ptr; }
+		Type& operator*() { return **_ptr; }
+		Node* operator&() {
+			return _ptr;
+		}
 	};
 
 private:
-	list_node dummy;
-	list_node* head = &dummy;
-	list_node* tail = &dummy;
+	Node dummy;
+	Node* head = &dummy;
+	Node* tail = &dummy;
 public:
-	list();
+	List();
 public:
 	iterator& operator[] (int index);
-	list& operator+= (const T& value);
+	List& operator+= (Type& value);
+	iterator append(Type& value);
 public:
 	iterator begin();
 	iterator end();