1 //CacheObj.h 2 3 #ifndef __CacheObj__ 4 #define __CacheObj__ 5 6 #include <iostream> 7 #include <stdexcept> 8 #include <malloc.h> 9 10 11 /* 12 * memory allocation class: Pre-allocates objects and 13 * maintains a freelist of objects that are unused 14 * When an object if freed, it is put back on the freelist 15 * some of the memory will be only returned when the program exist; 16 */ 17 template < typename Type > 18 class CacheObj 19 { 20 public: 21 static void* operator new(std::size_t); 22 #if 1 23 static void* operator new[](std::size_t); 24 #endif 25 26 static void operator delete(void*, std::size_t); 27 #if 1 28 static void operator delete[](void*, std::size_t); 29 #endif 30 31 virtual ~CacheObj(){} 32 33 protected: 34 Type *next; 35 static void list_free(void); 36 37 private: 38 static void add_to_freelist(Type *); 39 static Type* freelist; 40 static std::size_t unuse_size; //未用链表的长度不会超过2 * chunk; 41 static const std::size_t chunk; 42 }; 43 44 template < typename Type > Type* CacheObj< Type >::freelist = NULL; 45 template < typename Type > std::size_t CacheObj< Type >::unuse_size = 0; 46 template < typename Type > const std::size_t CacheObj< Type >::chunk = 2; 47 48 49 template < typename Type > 50 void* CacheObj< Type >::operator new(std::size_t size) 51 { 52 /* 53 * new should only be asked to build a Type; 54 * not an object derived from T; 55 * check that right size is requested 56 */ 57 if(size != sizeof(Type)) 58 { 59 throw std::runtime_error("CacheObj: wrong size object in operator new"); 60 } 61 62 63 //if list is empty: grab a new chunk of memory 64 //allocate allocates chunk number of objects of type Type 65 if(NULL == freelist) 66 { 67 #if 0 68 //一次申请大量数据空间，很爽啊，可是因为这种不计后果的行为，花费了大半天的时间 69 /*解释： 70 *很明显的bug例子：int *p = (int*)malloc(8*sizeof(int)); free(p); free(p+4); 71 *自己考虑的太不周全了 72 *使用一次性申请大量空间的bug出在： 73 * list_free()函数，其中每次free都以一个object的地址为参数,如同给出的bug示例，所以错了 74 * 75 */ 76 Type* array = (Type*)malloc(size * chunk); 77 if(NULL == array) 78 { 79 throw std::runtime_error("CacheObj: wrong size object in operator new"); 80 } 81 //谢谢陈涛，大神走了还有个人讨论，终于发现问题的所在了 82 #endif 83 84 //allocate allocates chunk number of objects of type T 85 for(unsigned int i = 0; i != chunk; i++) 86 { 87 #if 1 88 Type* array = (Type*)malloc(size); 89 if(NULL == array) 90 { 91 throw std::runtime_error("CacheObj: wrong size object in operator new"); 92 } 93 #endif 94 add_to_freelist(array); 95 #if 0 96 array++; 97 #endif 98 } 99 } 100 101 Type *p = freelist; 102 freelist = freelist->CacheObj< Type >::next; 103 unuse_size--; 104 p->CacheObj< Type >::next = NULL; 105 return p; 106 } 107 108 #if 1 109 template < typename Type > 110 void* CacheObj< Type >::operator new[](std::size_t size) 111 { 112 void *p = malloc(size); 113 return p; 114 } 115 #endif 116 117 template <typename Type > 118 void CacheObj< Type >::operator delete(void* p, std::size_t) 119 { 120 if(p != 0) 121 { 122 add_to_freelist(static_cast< Type* >(p)); 123 } 124 } 125 126 #if 1 127 template < typename Type > 128 void CacheObj< Type >::operator delete[](void* p, std::size_t) 129 { 130 if(!p) 131 free(p); 132 } 133 #endif 134 135 template < typename Type > 136 void CacheObj< Type >::list_free(void) 137 { 138 while(freelist) 139 { 140 Type *temp = freelist; 141 freelist = temp->CacheObj< Type >::next; 142 free(temp); 143 unuse_size--; 144 } 145 } 146 147 //puts object at head of the freelist 148 template < typename Type > 149 void CacheObj< Type >::add_to_freelist(Type *p) 150 { 151 if(!p) 152 return; 153 154 if(unuse_size >> 1 == chunk) 155 { 156 free(p); 157 return ; 158 } 159 160 unuse_size++; 161 p->CacheObj< Type >::next = freelist; 162 freelist = p; 163 } 164 165 #endif
//QueueItem.h #ifndef __QUEUEITEM__ #define __QUEUEITEM__ #include "CacheObj.h" template < typename Type > class Queue; //下面因为进行类模板特化，所以此处先声明 template < typename Type > std::ostream& operator<<(std::ostream&, const Queue< Type >&); //下面需要进行函数模特化，所以此处先声明 template < typename Type > class QueueItem: public CacheObj< QueueItem< Type > > { friend class Queue< Type >; //类模板特化 friend std::ostream& operator<< < Type >(std::ostream&, const Queue< Type >&); //函数模板特化 //private class : no public section; QueueItem(const Type &t): item(t), next(0){} Type item; //value stored in this element; QueueItem *next; //pointer to next element in the Queue; ~QueueItem(void) { next = NULL; } }; template < typename Type > class Queue { friend std::ostream& operator<< < Type >(std::ostream&, const Queue< Type >&); //函数模板特化 public: //empty Queue Queue(void):head(0), tail(0){} //copy control to manage pointers to QueueItems in the Queue Queue(const Queue &Q):head(0), tail(0) { copy_elems(Q); } template < typename Iter > Queue(Iter beg, Iter end); //成员模板 ~Queue(void); Queue& operator=(const Queue&); Type& front(void); const Type& front(void) const; //return element from head of Queue; void push(const Type&); //add element to back of Queue; void pop(void); //remove element from head of Queue; bool empty(void)const; //true if no elements in Queue; private: QueueItem< Type >* head; //pointer to first element in Queue; QueueItem< Type >* tail; //pointer to last element in Queue; //utility functions used by copy constructor, assignment, and destructor void destroy(void); //delete all the elements; void copy_elems(const Queue&); //copy elements from parameter template < typename Iter > void copy_elems(Iter beg, Iter end); //成员模板，且重载上一函数 }; //成员模板实现 template < typename Type > template < typename Iter > Queue< Type >::Queue(Iter beg, Iter end):head(0), tail(0) { destroy(); copy_elems(beg, end); } template < typename Type > Queue< Type >::~Queue(void) { destroy(); } template < typename Type > Queue< Type >& Queue< Type >::operator=(const Queue<Type>& src) { Queue< Type >* pt = head; if(head != 0) { while(pt) { QueueItem< Type >* temp = pt; pt = pt->next; delete temp; } } head = tail = 0; copy_elems(src); } template < typename Type > Type& Queue< Type >::front(void) { return head->item; } template < typename Type > const Type& Queue< Type >::front(void) const { return head->item; } template < typename Type > void Queue< Type >::push(const Type& val) { //allocate a new QueueItem object; QueueItem< Type >* pt = new QueueItem< Type >(val); //put item onto existing queue; if(empty()) { head = tail = pt; //the queue now has only one element; } else { tail->next = pt; //add new element to end of the queue; tail = pt; } } //pop is unchecked: Popping off an empty Queue is undefined; template < typename Type > void Queue< Type >::pop(void) { QueueItem< Type >* p = head; //keep pointer to head so we can delete it; head = head->next; //head now points to next element; delete p; //delete old head element; } template < typename Type > bool Queue< Type >::empty(void)const { return head == 0; } //成员函数实现 template < typename Type > void Queue< Type >::destroy(void) { while(!empty()) pop(); QueueItem< Type >::list_free(); } //copy elements from orig into this Queue; //loop stops when pt == 0, which happens when we reach orig.tail; template < typename Type > void Queue< Type >::copy_elems(const Queue< Type >& orig) { for(QueueItem< Type >*pt = orig.head; pt = pt->next;) { push(pt->item); } } //成员模板实现 template < typename Type > template < typename Iter > void Queue< Type >::copy_elems(Iter beg, Iter end) { while(beg != end) { push(*beg); ++beg; } } //普通函数模板 template < typename Type > std::ostream& operator<<(std::ostream &os, const Queue< Type >& q) { os << "< "; QueueItem< Type >*p; for(p = q.head; p ; p = p->next) { os << p->item << " "; } os << ">"; return os; } #endif
1 //test.cpp 2 3 #include <iostream> 4 #include "QueueItem.h" 5 6 int main(void) 7 { 8 int array[5] = {4, 6, 7, 8, 90}; 9 Queue<int> qi(array + 0, array + 5); 10 short s = 42; 11 qi.push(s); 12 qi.pop(); 13 qi.pop(); 14 qi.pop(); 15 qi.push(s); 16 qi.push(s); 17 std::cout << qi << std::endl; 18 19 return 0; 20 }