remove the handout version

lectures/11_list_implementation/dslist_handout.h

@@ -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 <cassert>
-
-// -----------------------------------------------------------------
-// NODE CLASS
-template <class T>
-class Node {
-public:
-  Node() : next_(NULL), prev_(NULL) {}
-  Node(const T& v) : value_(v), next_(NULL), prev_(NULL) {}
-
-  // REPRESENTATION
-  T value_;
-  Node<T>* next_;
-  Node<T>* prev_;
-};
-
-// A "forward declaration" of this class is needed
-template <class T> class dslist;
-
-// -----------------------------------------------------------------
-// LIST ITERATOR
-template <class T>
-class list_iterator {
-public:
-  // default constructor, copy constructor, assignment operator, & destructor
-  list_iterator() : ptr_(NULL) {}
-  list_iterator(Node<T>* p) : ptr_(p) {}
-  list_iterator(const list_iterator<T>& old) : ptr_(old.ptr_) {}
-  list_iterator<T>& operator=(const list_iterator<T>& 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<T>& operator++() { // pre-increment, e.g., ++iter
-    ptr_ = ptr_->next_;
-    return *this;
-  }
-  list_iterator<T> operator++(int) { // post-increment, e.g., iter++
-    list_iterator<T> temp(*this);
-    ptr_ = ptr_->next_;
-    return temp;
-  }
-  list_iterator<T>& operator--() { // pre-decrement, e.g., --iter
-    ptr_ = ptr_->prev_;
-    return *this;
-  }
-  list_iterator<T> operator--(int) { // post-decrement, e.g., iter--
-    list_iterator<T> temp(*this);
-    ptr_ = ptr_->prev_;
-    return temp;
-  }
-  // the dslist class needs access to the private ptr_ member variable
-  friend class dslist<T>;
-
-  // Comparions operators are straightforward
-  bool operator==(const list_iterator<T>& r) const {
-    return ptr_ == r.ptr_; }
-  bool operator!=(const list_iterator<T>& r) const {
-    return ptr_ != r.ptr_; }
-
-private:
-  // REPRESENTATION
-  Node<T>* ptr_;    // ptr to node in the list
-
-};
-
-// -----------------------------------------------------------------
-// LIST CLASS DECLARATION
-// Note that it explicitly maintains the size of the list.
-template <class T>
-class dslist {
-public:
-  // default constructor, copy constructor, assignment operator, & destructor
-  dslist() : head_(NULL), tail_(NULL), size_(0) {}
-  dslist(const dslist<T>& old) { this->copy_list(old); }
-  dslist& operator= (const dslist<T>& 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<T> 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<T>& old);
-  void destroy_list();
-
-  //REPRESENTATION
-  Node<T>* head_;
-  Node<T>* tail_;
-  unsigned int size_;
-};
-
-// -----------------------------------------------------------------
-// LIST CLASS IMPLEMENTATION
-template <class T>
-dslist<T>& dslist<T>::operator= (const dslist<T>& old) {
-  // check for self-assignment
-  if (&old != this) {
-    this->destroy_list();
-    this->copy_list(old);
-  }
-  return *this;
-}
-
-template <class T>
-void dslist<T>::push_front(const T& v) {
-
-
-
-
-
-}
-
-template <class T>
-void dslist<T>::pop_front() {
-
-
-
-
-}
-
-template <class T>
-void dslist<T>::push_back(const T& v) {
-
-
-
-
-
-}
-
-template <class T>
-void dslist<T>::pop_back() {
-
-
-
-
-}
-
-// do these lists look the same (length & contents)?
-template <class T>
-bool operator== (dslist<T>& left, dslist<T>& right) {
-  if (left.size() != right.size()) return false;
-  typename dslist<T>::iterator left_itr = left.begin();
-  typename dslist<T>::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 <class T>
-bool operator!= (dslist<T>& left, dslist<T>& right){ return !(left==right); }
-template <class T>
-typename dslist<T>::iterator dslist<T>::erase(iterator itr) {
-
-
-
-
-
-
-
-
-
-
-
-
-}
-
-template <class T>
-typename dslist<T>::iterator dslist<T>::insert(iterator itr, const T& v) {
-
-
-
-
-
-
-
-
-
-
-}
-
-template <class T>
-void dslist<T>::copy_list(const dslist<T>& old) {
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-}
-
-template <class T>
-void dslist<T>::destroy_list() {
-
-
-
-
-
-
-
-}
-
-#endif

lectures/11_list_implementation/list.h

@@ -7,6 +7,7 @@ class Node {
 	private:
 };
 
+// A "forward declaration" of this class is needed
 template <class T> class dslist;
 
 template <class T>
@@ -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<T>;
 	private:
 		Node<T>* ptr;