#include <iostream> #include <memory> #include <algorithm> #include <cassert> using namespace std; /*用allocator类管理内存,来模拟vector 作者:blackmanba 时间:2010年10月6日 */ #define MAX(a,b) ((a>b)? (a):(b)) /*模拟vector类*/ template <typename T> class Vector { public: Vector():elements(NULL), first_free(NULL), end(NULL){} void push_back(const T& t);//插入元素 void reserve(const int& n);//该变向量的容量 void resize(const int& n);//改变向量所包含元素的个数 T& operator[](const int &i);//重载小标运算符 size_t size() const;//返回元素个数 //声明Vector的迭代器 typedef T* iterator; iterator begin();//返回首元素的迭代器 iterator back();//返回最后一个元素后面的迭代器 private: static allocator<T> alloc;//获得原始内存的对象 void reallocate();//获得更大的内存空间并拷贝已存在的元素 T* elements; //指向数组中第一个元素的指针 T* first_free;//指向数组中第一个实际元素之后的指针 T* end;//指向数组本身之后的那个元素 }; template <typename T> allocator<T> Vector<T>::alloc ; int main() { Vector<int> vec; int i; for (i=0; i<10; i++) { vec.push_back(i+1); } vec.reserve(20); vec.resize(30); cout<<vec.size()<<endl; for (i=0; i<vec.size(); i++) { cout<<vec[i]<<" "; } cout<<endl; vec.reserve(15); vec.resize(13); //用迭代器来访问 Vector<int>::iterator iter1 = vec.begin(); Vector<int>::iterator iter2 = vec.back(); while (iter1 != iter2) { cout<<*iter1++<<" "; } cout<<endl; allocator<int> alloc;//创建对象 int* p = alloc.allocate(10, NULL);//分配内存 for (i=0; i<10; ++i) { alloc.construct(p+i, i+1);//初始元素 } alloc.deallocate(p, 10);//删除分配的内存 } //插入元素 template <typename T> void Vector<T>::push_back(const T& t) { //判断分配的空间是否已经满了 if (first_free == end) { reallocate();//获得更多的空间,并把原先的元素拷贝到新分配的空间 } alloc.construct(first_free, t);//使用类型T的复制构造函数将t值复制到由first_free指向的元素 ++first_free; } //获得更大的内存空间并拷贝已存在的元素 template <typename T> void Vector<T>::reallocate() { ptrdiff_t size = first_free - elements;//计算当前数组中的元素个数 ptrdiff_t newcapacity = 2 * MAX(size, 1);//每次分配的空间是前一次的2倍 T* newelements = alloc.allocate(newcapacity, NULL); //分配新的空间,并把新空间的地址赋给newelements uninitialized_copy(elements, first_free, newelements);//复制构造每一元素 for (T* p = first_free; p != elements; )//按逆序析构原先的元素 { alloc.destroy(--p);//运行T类型的析构函数来释放旧元素所用的任何资源 } if (elements != NULL) { alloc.deallocate(elements, end - elements);//释放存放旧元素的内存 } //改变数据指针 elements = newelements; first_free = elements + size; end = elements + newcapacity; } //该变向量的容量 template <typename T> void Vector<T>::reserve(const int& n) { ptrdiff_t capacity = end - elements;//计算当前向量的容量 ptrdiff_t size = first_free - elements;//计算当前数组中的元素个数 //如新容量大于原先的,要进行分配 if (n > capacity) { T* newelements = alloc.allocate(n, NULL); //分配新的空间,并把新空间的地址赋给newelements uninitialized_copy(elements, first_free, newelements);//复制构造每一元素 for (T* p = first_free; p != elements; )//按逆序析构原先的元素 { alloc.destroy(--p);//运行T类型的析构函数来释放旧元素所用的任何资源 } if (elements != NULL) { alloc.deallocate(elements, end - elements);//释放存放旧元素的内存 } //改变数据指针 elements = newelements; first_free = elements + size; end = elements + n; } else //如果新容量小于原容量,不分配,并且要删除多余的 { T* newelements = alloc.allocate(n, NULL); //分配新的空间,并把新空间的地址赋给newelements uninitialized_copy(elements, elements+n, newelements);//复制构造每一元素 for (T* p = first_free; p != elements; )//按逆序析构原先的元素 { alloc.destroy(--p);//运行T类型的析构函数来释放旧元素所用的任何资源 } if (elements != NULL) { alloc.deallocate(elements, end - elements);//释放存放旧元素的内存 } //改变数据指针 elements = newelements; first_free = elements + size; end = elements + n; } } //重载下标运算符 template <typename T> T& Vector<T>::operator[](const int &i) { int s = size(); assert(0<=i && i<s); return *(elements + i); } //返回元素个数 template <typename T> size_t Vector<T>::size() const { return (first_free - elements); } //改变向量所包含元素的个数 template <typename T> void Vector<T>::resize(const int& n) { int s = size(); //若新size小于原来的,要删除元素 if (n < s) { for (T* p = first_free; p != elements+n; )//按逆序析构原先的元素 { alloc.destroy(--p);//运行T类型的析构函数来释放旧元素所用的任何资源 } first_free = elements + n; } else { //大于的话,只用添加元素即可,会自动增加容量的 for (int i=0; i<n-s; i++) { push_back(T()); } } } //返回首元素的迭代器 template <typename T> Vector<T>::iterator Vector<T>::begin() { return elements; } //返回最后一个元素后面的迭代器 template <typename T> Vector<T>::iterator Vector<T>::back() { return first_free; }