c++ vector的简单实现

vector的简单实现， 实现了简单迭代器 

// 文件名:kkvector.h
#ifndef __VECTOR_H__
#define __VECTOR_H__

#include <algorithm>

template <typename Object>
class vector
{
public:
	static const int kSpareSize = 16;
public:
	explicit vector (int size = 0, const Object& obj = Object())
		: size_(size),
		  capacity_(size + kSpareSize),
		  obj_(new Object[capacity_])
		{
			for (size_t i = 0; i < size_; ++i)
				obj_[i] = obj;
		}

	vector(const vector& other)
		: size_(other.size()),
		  capacity_(other.capacity()),
		  obj_(new Object[capacity_])
	{
		for (size_t i = 0; i < size_; ++i)
		{
			obj_[i] = other[i];
		}
	}

	~vector()
	{
		delete []obj_;
	}

	Object& operator=(const Object& object)
	{
		vector tmp = object;
		std::swap(*this, tmp);
		return *this;
	}

	size_t size() const
	{
		return size_;
	}

	size_t capacity() const
	{
		return capacity_;
	}

	bool isEmpty() const
	{
		return size() == 0;
	}

	void resize(size_t size, const Object& object = Object())
	{
		if (size > capacity_)
			reserve(size);
		for (size_t i = size_; i < size; ++i) {
			obj_[i] = object;
		}
		size_ = size;
	}

	void reserve(size_t capacity)
	{
		if (capacity <= capacity_) return;

		Object *obj = new Object[capacity];
		for (size_t i = 0; i < size_; ++i)
			obj[i] = std::move(obj_[i]);
		std::swap(obj_, obj);
		capacity_ = capacity;
		delete [] obj;
	}

	void push_back(const Object& obj)
	{
		if (size_ >= capacity_)
			reserve(capacity_*2);
		obj_[size_++] = obj;
	}

	void push_back(const Object&& obj)
	{
		if (size_ >= capacity_)
			reserve(capacity_*2);
		obj_[size_++] = std::move(obj);
	}

	const Object& back() const
	{
		return obj_[size_ - 1];
	}

	Object& back()
	{
		return obj_[size_ - 1];
	}

	void pop_back()
	{
		--size_;
	}

	Object& operator[](size_t idx)
	{
		return obj_[idx];
	}

	const Object& operator[](size_t idx) const
	{
		return obj_[idx];
	}

	Object& at(size_t idx)
	{
		return obj_[idx];
	}
	
private:
	size_t size_;
	size_t capacity_;
	Object *obj_;

public:
	typedef Object * iterator;
	typedef const Object * const_iterator;

	iterator begin()
	{
		return &obj_[0];
	}

	iterator end()
	{
		return &obj_[size_];
	}

	const_iterator begin() const
	{
		return &obj_[0];
	}

	const_iterator end() const
	{
		return &obj_[size_];
	}
};

#endif // __VECTOR_H__

以下是简单的测试

//kkvector_test
#include <iostream>
#include "kkvector.h"

template<typename T>
void printVec(const vector<T>& _vector)
{
    for (size_t i = 0; i < _vector.size(); ++i)
    {
        std::cout << _vector[i] << " ";
    }
    std::cout << std::endl;
}
int main()
{

    vector<int> v1;
    v1.resize(10);
    std::cout << "v1.size" << v1.size() << "v1.capacity" << v1.capacity() << std::endl;
    v1.reserve(1);
    std::cout << "v1.size" << v1.size() << "v1.capacity" << v1.capacity() << std::endl;
    for (size_t i = 0; i < 100; ++i)
    {
        v1.push_back(i);
    }
    std::cout << "v1.size" << v1.size() << "v1.capacity" << v1.capacity() << std::endl;
    printVec(v1);
    std::cout << "v1.back" << v1.back() << std::endl;
    v1.pop_back();
    for (vector<int>::iterator iter = v1.begin(); iter != v1.end(); ++iter)
    {
         std::cout << *iter << " ";
    }
    std::cout << std::endl;
    return 0;
}