list.inl 2.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105
  1. #include "list.h"
  2. #define HOLDER
  3. #define __TEMPLATE template<typename Type>
  4. #define TEMPLATE(rtype) __TEMPLATE rtype
  5. #define ADT List<Type>
  6. #define NODE ADT::Node
  7. #define ITERATOR ADT::iterator
  8. // #pragma region List<Type>::iterator
  9. TEMPLATE(HOLDER) ITERATOR::iterator(Node* ptr) {
  10. _ptr = ptr;
  11. }
  12. TEMPLATE(typename ITERATOR&) ITERATOR::operator++() {
  13. _ptr = _ptr->_next;
  14. return *this;
  15. }
  16. TEMPLATE(typename ITERATOR&) ITERATOR::operator--() {
  17. _ptr = _ptr->_prev;
  18. return *this;
  19. }
  20. TEMPLATE(bool) ITERATOR::operator== (const ITERATOR& it) {
  21. // TBD 其它信息比较
  22. return _ptr == it._ptr;
  23. }
  24. TEMPLATE(bool) ITERATOR::operator!= (const ITERATOR& it) {
  25. return !(*this == it);
  26. }
  27. // #pragma endregion
  28. // #pragma region List<Type>
  29. TEMPLATE(HOLDER) ADT::List() : dummy(&dummy, &dummy) {};
  30. TEMPLATE(HOLDER) ADT::~List() {
  31. Node* curr = head->_next;
  32. Node* next = nullptr;
  33. for (; curr != &dummy;) {
  34. next = curr->_next;
  35. delete curr;
  36. curr = next;
  37. }
  38. }
  39. TEMPLATE(size_t) ADT::erase(Type& target) {
  40. Node* curr = head->_next;
  41. Node* next = nullptr;
  42. for (; curr != &dummy;) {
  43. if (curr->_value == target) {
  44. erase(curr->value);
  45. return (size_t)1ull;
  46. }
  47. }
  48. return (size_t)0ull;
  49. }
  50. TEMPLATE(void) ADT::erase(Node* node) {
  51. node->_prev->_next = node->_next;
  52. node->_next->_prev = node->_prev;
  53. delete node;
  54. }
  55. TEMPLATE(typename ITERATOR) ADT::begin() { return ADT::iterator(head->_next); }
  56. TEMPLATE(typename ITERATOR) ADT::end() { return ADT::iterator(head); }
  57. TEMPLATE(typename ITERATOR) ADT::rbegin() { return ADT::iterator(tail->_prev); }
  58. TEMPLATE(typename ITERATOR) ADT::rend() { return ADT::iterator(tail); }
  59. TEMPLATE(typename ITERATOR&) ADT::operator[] (int index) {
  60. Node* curr = head;
  61. for (; index >= 0; --index) {
  62. if (curr == nullptr) {
  63. return end();
  64. }
  65. curr = curr->next;
  66. }
  67. return iterator(curr);
  68. }
  69. TEMPLATE(ADT&) ADT::operator+= (Type& value) {
  70. Node* node = new Node(value, tail->_prev, tail);
  71. tail->_prev->_next = node;
  72. tail->_prev = node;
  73. return *this;
  74. }
  75. TEMPLATE(typename ITERATOR) ADT::append(Type& value) {
  76. Node* node = new Node(value, tail->_prev, tail);
  77. tail->_prev->_next = node;
  78. tail->_prev = node;
  79. return iterator(node);
  80. }
  81. // #pragma endregion
  82. #undef HOLDER
  83. #undef __TEMPLATE
  84. #undef TEMPLATE
  85. #undef ADT
  86. #undef NODE
  87. #undef ITERATOR