C++ Primer 学习笔记_82_模板与泛型编程 --类模板成员[续2](一)

2014-11-24 13:11:01 · 作者: · 浏览: 7

模板与泛型编程

--类模板成员[续2]

六、完整的Queue

Queue的完整定义:


template 
  
    class Queue;

template 
   
     ostream &operator<<(ostream &,const Queue
    
      &); template 
     
       class QueueItem { friend class Queue
      
       ; friend ostream & operator<< 
       
        (ostream &,const Queue
        
          &); QueueItem(const Type &t):item(t),next(0) {} Type item; QueueItem *next; }; template 
         
           class Queue { friend ostream & operator<< 
          
           (ostream &,const Queue
           
             &); public: Queue():head(0),tail(0) {} template 
            
              Queue(Iter beg,Iter end):head(0),tail(0) { copy_elems(beg,end); } Queue(const Queue &Q):head(0),tail(0) { copy_elems(Q); } Queue &operator=(const Queue &); ~Queue() { destroy(); } template 
             
               void assign(Iter,Iter); Type &front() { return head -> item; } const Type &front() const { return head -> item; } void push(const Type &); void pop(); bool empty() const { return head == 0; } private: QueueItem
              
                *head; QueueItem
               
                 *tail; void destroy(); void copy_elems(const Queue &); template 
                
                  void copy_elems(Iter,Iter); }; #include “Queue.cpp” 
                
               
              
             
            
           
          
         
        
       
      
     
    
   
  


//P559 习题16.43 + P551习题16.34
template 
  
    class List;
template 
   
     class ListItem { friend class List
    
     ; ListItem(Type &t):item(t),next(0) {} Type item; ListItem *next; }; template 
     
       class List { public: List():front(0),end(0) {} List(const List &rhs):front(0),end(0) { copy_elems(rhs); } template 
      
        List(Iter first,Iter last):front(first),end(last) { copy_elems(first,last); } List &operator=(const List &rhs); ~List() { destroy(); } void insert(ListItem
       
         *ptr,Type &value); void del(ListItem
        
          *ptr); ListItem
         
           *find(const Type &value); ListItem
          
            *first() const { return front; } ListItem
           
             *last() const { return end; } bool empty() const { return front == 0; } Type &getElem(ListItem
            
              *ptr) { return ptr -> item; } template 
             
               void assign(Iter,Iter); private: ListItem
              
                *front,*end; void destroy(); void copy_elems(List &); template 
               
                 void copy_elems(Iter,Iter); }; template 
                
                  void List
                 
                  ::destroy() { while (!empty()) del(front); } template 
                  
                    void List
                   
                    ::del(ListItem
                    
                      *ptr) { ListItem
                     
                       *p = front; while (p != 0 && p != ptr && p -> next != ptr) { p = p -> next; } if (p != 0) { if (p == ptr) { front = ptr -> next; } else { p -> next = ptr -> next; } if (ptr == end) { end = ptr -> next; } delete ptr; } else { throw out_of_range("no such element"); } } template 
                      
                        void List
                       
                        ::insert(ListItem
                        
                          *ptr,Type &val) { ListItem
                         
                           *pt = new ListItem
                          
                           (val); if (empty()) { front = pt; } else { pt -> next = ptr -> next; ptr -> next = pt; } if (ptr == end) { end = pt; } } template 
                           
                             void List
                            
                             ::copy_elems(List
                             
                               &rhs) { for (ListItem
                              
                                *pt = rhs.front; pt ; pt = pt -> next) { insert(end,pt -> item); } } template 
                               
                                 template 
                                
                                  void List
                                 
                                  ::copy_elems(Iter first,Iter last) { while (first != last) { insert(end,first -> item); first = first -> next; } insert(end,first -> item); } template 
                                  
                                    List
                                   
                                     &List
                                    
                                     ::operator=(const List
                                     
                                       &rhs) { destroy(); copy_elems(rhs); } template 
                                      
                                        ListItem
                                       
                                         *List
                                        
                                         ::find(const Type &value) { ListItem
                                         
                                           *pt = front; while (pt && pt -> item != value) { pt = pt -> next; } return pt; } template 
                                          
                                            template 
                                           
                                             void List
                                            
                                             ::assign(Iter first,Iter last) { destroy(); copy_elems(first,last); } 
                                            
                                           
                                          
                                         
                                        
                                       
                                      
                                     
                                    
                                   
                                  
                                 
                                
                               
                              
                             
                            
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      
     
    
   
  

//习题16.44
template 
  
    class Queue;
template 
   
     ostream &operator<<(ostream &os,const Queue
    
      &); template 
     
       class Queue { friend ostream &operator<< 
      
       (ostream &os,const Queue
       
         &); public: Queue() {} template 
        
          Queue(Iter beg,Iter end):items(beg,end) {} template 
         
           void assign(Iter beg,Iter end) { items.assign(beg,end); } Type &front() { return items.front(); } const Type &f