java vector迭代器_vector容器、迭代器和空间配置器三个类方法的实现

C++的STL库有一个容器叫vector，这个容器底层的数据结构是一个内存可以自动增长的数组，每次当数组存储满了以后，内存可以自动增加两倍，请完成vector容器、迭代器和空间配置器三个类方法的实现。

#include

using namespace std;

//容器默认的空间配置器的实现

template

class myallocator

{

public:

T* allocate(size_t size) //开辟内存

{

return (T*)malloc(size);

}

void deallocate(void *ptr) //释放内存

{

free(ptr);

}

void construct(T *ptr, const T &val)//构造对象

{

new(ptr)T(val);

}

void destroy(T *ptr) //析构对象

{

ptr->~T();

}

};

//容器的类模板

template>

class Vector

{

public:

//迭代器类型前置声明

class iterator;

//默认构造函数

Vector(int size = 5)

{

_first = _allocator.allocate(size*sizeof(E));

_end = _first + size;

_last = _first;

}

//析构函数

~Vector()

{

int size = _last - _first;

for (int i = 0; i < size; ++i)

{

_allocator.destroy(_first + i);

}

_allocator.deallocate(_first);

_first = _last = _end = NULL;

}

//拷贝构造函数

Vector(const Vector &src)

{

int length = src._end - src._first;

_first = _allocator.allocate(length*sizeof(E));

int size = src._last - src._first;

for (int i = 0; i < size; ++i)

{

_allocator.construct(_first + i, src._first[i]);

}

_end = _first + size;

_last = _first + length;

}

//赋值运算符的重载函数

Vector& operator=(const Vector &src)

{

if (this == &src)

{

return*this;

}

int size = _last - _first;

for (int i = 0; i < size; ++i)

{

_allocator.destroy(_first + i);

}

_allocator.deallocate(_first);

_first = _last = _end = NULL;

int length = src._end - src._first;

_first = _allocator.allocate(length*sizeof(E));

int size = src._last - src._first;

for (int i = 0; i < size; ++i)

{

_allocator.construct(_first + i, src._first[i]);

}

_end = _first + size;

_last = _first + length;

}

//向容器的末尾添加新元素value，若增长内存，调用resize函数

void push_back(const E &value)

{

if (full())

{

resize();

}

_allocator.construct(_last, value);

_last++;

}

//删除容器末尾的元素

void pop_back()

{

if (empty())

{

return;

}

_last--;

_allocator.destroy(_last);

}

//向指定位置插入新元素value，若增长内存，调用resize函数

iterator insert(iterator it, const E &value)

{

if (it.mptr<_first it.mptr>_last)

{

return _last;

}

if (_last == _end)

{

int offset = it.mptr - _first;

resize();

it.mptr = _first + offset;

}

E*p = _last;

for (; p > it.mptr; --p)

{

_allocator.construct(p, *(p - 1));

_allocator.destroy(p - 1);

}

_allocator.construct(p, value);

_last++;

return p;

}

//删除指定位置的元素

iterator erase(iterator it)

{

if (it.mptr<_first it.mptr>= _last)

{

return _last;

}

E*p = it.mptr;

for (; p < _last - 1; ++p)

{

_allocator.destroy(p);

_allocator.construct(p, *(p + 1));

}

_allocator.destroy(p);

--_last;

return it.mptr;

}

//判断容器是否空

bool empty()const{ return _first == _last; }

//判断容器是否满

bool full()const{ return _last == _end; }

//容器的迭代器实现

class iterator

{

public:

iterator(E*ptr = NULL) :mptr(ptr){}

bool operator!=(const iterator&it)

{

return mptr != it.mptr;

}

void operator++()

{

mptr++;

}

E&operator*()

{

return*mptr;

}

E*mptr;

};

iterator begin(){ return iterator(_first); }

iterator end(){ return iterator(_last); }

private:

//内存增长函数，按原有容量的两倍增长

void resize()

{

int size = _last - _first;

E*ptmp = _allocator.allocate((size)*sizeof(E)* 2);

for (int i = 0; i < size; ++i)

{

_allocator.construct(ptmp + i, _first[i]);

}

for (int i = 0; i < size; ++i)

{

_allocator.destroy(_first + i);

}

_allocator.deallocate(_first);

_first = ptmp;

_end = _first + size * 2;

_last = _first + size;

}

E *_first; //指向数组的起始位置

E *_end; //指向数组的末尾的后继位置

E *_last; //指向数组最后一个有效数据的后继位置

allocator _allocator; // vector容器的空间配置器

};

int main()

{

VectorVec;

Vec.push_back(20);

Vec.push_back(21);

Vec.push_back(22);

Vec.push_back(23);

Vec.push_back(24);

Vec.push_back(25);

Vec.push_back(26);

Vec.pop_back();

Vec.erase(Vec.begin());

Vec.insert(Vec.begin(),66);

Vector::iterator it = Vec.begin();

for (; it != Vec.end(); ++it)

{

cout << *it << " ";

}

cout << endl;

return 0;

}

运行结果如下：