From 6e31ccccbf22012a9ae9d0604c063bbeb91bf1fe Mon Sep 17 00:00:00 2001 From: Jidong Xiao Date: Fri, 6 Oct 2023 13:44:56 -0400 Subject: [PATCH] remove the handout version --- .../11_list_implementation/dslist_handout.h | 245 ------------------ lectures/11_list_implementation/list.h | 2 + 2 files changed, 2 insertions(+), 245 deletions(-) delete mode 100644 lectures/11_list_implementation/dslist_handout.h diff --git a/lectures/11_list_implementation/dslist_handout.h b/lectures/11_list_implementation/dslist_handout.h deleted file mode 100644 index d6c310b..0000000 --- a/lectures/11_list_implementation/dslist_handout.h +++ /dev/null @@ -1,245 +0,0 @@ -#ifndef dslist_h_ -#define dslist_h_ -// A simplified implementation of a generic list container class, -// including the iterator, but not the const_iterators. Three -// separate classes are defined: a Node class, an iterator class, and -// the actual list class. The underlying list is doubly-linked, but -// there is no dummy head node and the list is not circular. -#include - -// ----------------------------------------------------------------- -// NODE CLASS -template -class Node { -public: - Node() : next_(NULL), prev_(NULL) {} - Node(const T& v) : value_(v), next_(NULL), prev_(NULL) {} - - // REPRESENTATION - T value_; - Node* next_; - Node* prev_; -}; - -// A "forward declaration" of this class is needed -template class dslist; - -// ----------------------------------------------------------------- -// LIST ITERATOR -template -class list_iterator { -public: - // default constructor, copy constructor, assignment operator, & destructor - list_iterator() : ptr_(NULL) {} - list_iterator(Node* p) : ptr_(p) {} - list_iterator(const list_iterator& old) : ptr_(old.ptr_) {} - list_iterator& operator=(const list_iterator& old) { - ptr_ = old.ptr_; return *this; } - ~list_iterator() {} - - // dereferencing operator gives access to the value at the pointer - T& operator*() { return ptr_->value_; } - - // increment & decrement operators - list_iterator& operator++() { // pre-increment, e.g., ++iter - ptr_ = ptr_->next_; - return *this; - } - list_iterator operator++(int) { // post-increment, e.g., iter++ - list_iterator temp(*this); - ptr_ = ptr_->next_; - return temp; - } - list_iterator& operator--() { // pre-decrement, e.g., --iter - ptr_ = ptr_->prev_; - return *this; - } - list_iterator operator--(int) { // post-decrement, e.g., iter-- - list_iterator temp(*this); - ptr_ = ptr_->prev_; - return temp; - } - // the dslist class needs access to the private ptr_ member variable - friend class dslist; - - // Comparions operators are straightforward - bool operator==(const list_iterator& r) const { - return ptr_ == r.ptr_; } - bool operator!=(const list_iterator& r) const { - return ptr_ != r.ptr_; } - -private: - // REPRESENTATION - Node* ptr_; // ptr to node in the list - -}; - -// ----------------------------------------------------------------- -// LIST CLASS DECLARATION -// Note that it explicitly maintains the size of the list. -template -class dslist { -public: - // default constructor, copy constructor, assignment operator, & destructor - dslist() : head_(NULL), tail_(NULL), size_(0) {} - dslist(const dslist& old) { this->copy_list(old); } - dslist& operator= (const dslist& old); - ~dslist() { this->destroy_list(); } - - // simple accessors & modifiers - unsigned int size() const { return size_; } - bool empty() const { return head_ == NULL; } - void clear() { this->destroy_list(); } - - // read/write access to contents - const T& front() const { return head_->value_; } - T& front() { return head_->value_; } - const T& back() const { return tail_->value_; } - T& back() { return tail_->value_; } - - // modify the linked list structure - void push_front(const T& v); - void pop_front(); - void push_back(const T& v); - void pop_back(); - - typedef list_iterator iterator; - iterator erase(iterator itr); - iterator insert(iterator itr, const T& v); - iterator begin() { return iterator(head_); } - iterator end() { return iterator(NULL); } - -private: - // private helper functions - void copy_list(const dslist& old); - void destroy_list(); - - //REPRESENTATION - Node* head_; - Node* tail_; - unsigned int size_; -}; - -// ----------------------------------------------------------------- -// LIST CLASS IMPLEMENTATION -template -dslist& dslist::operator= (const dslist& old) { - // check for self-assignment - if (&old != this) { - this->destroy_list(); - this->copy_list(old); - } - return *this; -} - -template -void dslist::push_front(const T& v) { - - - - - -} - -template -void dslist::pop_front() { - - - - -} - -template -void dslist::push_back(const T& v) { - - - - - -} - -template -void dslist::pop_back() { - - - - -} - -// do these lists look the same (length & contents)? -template -bool operator== (dslist& left, dslist& right) { - if (left.size() != right.size()) return false; - typename dslist::iterator left_itr = left.begin(); - typename dslist::iterator right_itr = right.begin(); - // walk over both lists, looking for a mismatched value - while (left_itr != left.end()) { - if (*left_itr != *right_itr) return false; - left_itr++; right_itr++; - } - return true; -} -template -bool operator!= (dslist& left, dslist& right){ return !(left==right); } -template -typename dslist::iterator dslist::erase(iterator itr) { - - - - - - - - - - - - -} - -template -typename dslist::iterator dslist::insert(iterator itr, const T& v) { - - - - - - - - - - -} - -template -void dslist::copy_list(const dslist& old) { - - - - - - - - - - - - - - - - -} - -template -void dslist::destroy_list() { - - - - - - - -} - -#endif diff --git a/lectures/11_list_implementation/list.h b/lectures/11_list_implementation/list.h index c742cad..ee44eb8 100644 --- a/lectures/11_list_implementation/list.h +++ b/lectures/11_list_implementation/list.h @@ -7,6 +7,7 @@ class Node { private: }; +// A "forward declaration" of this class is needed template class dslist; template @@ -48,6 +49,7 @@ class list_iterator { return (this->ptr != other.ptr); } + // the dslist class needs access to the private ptr_ member variable friend class dslist; private: Node* ptr;