vector.h

简单数据库管理系统

// Vector.h: interface for the Vector class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_VECTOR_H__EA7E68E5_F020_4663_B809_9018E0603CBF__INCLUDED_)
#define AFX_VECTOR_H__EA7E68E5_F020_4663_B809_9018E0603CBF__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <IOSTREAM>
#include <NEW.H>

template<class T>
class Vector  
{
public:
	typedef T* iterator_;
	typedef T& reference_;
	typedef size_t size_type;
	typedef const T * const_iterator_;
	typedef const T & const_reference_;
public:
	Vector():ptr_(0),size_(0),capacity_(0){}

	virtual ~Vector()
	{
		if (ptr_)
		{
			for (size_type i = 0; i < size_; i++)
				((iterator_)(ptr_+i))->~T();
			size_ = 0;
			capacity_ = 0;
			::operator delete ((void*)ptr_);
			ptr_ = 0;
		}
	}

	Vector(const Vector<T> & t_)
		:ptr_(0),size_(0),capacity_(0)
	{
		insert(ptr_, t_.ptr_, (t_.ptr_ + t_.size_));
	}

	Vector<T> & operator = (const Vector<T> & t_)
	{
		if(this == &t_)
			return *this;
		clear();
		insert(ptr_, t_.ptr_, t_.ptr_ + t_.size_);
		return *this;
	}
	
	void insert(iterator_ p_,size_type n_,const_reference_ t_)
	{
		size_type i = p_ - ptr_;
		//to adjust size 
		resize(size_ + n_);
		//to insert units
	
		if( i != size_)
			memmove(ptr_ + n_ + i, ptr_ + i, (size_ - i) * sizeof(T));
		for(iterator_ pp_ = ptr_ + i; n_ > 0 ; n_--,pp_++)
		{
			(void)new(pp_) T(t_);
			size_++;
		}
	}

	void insert(iterator_ p_,const_iterator_ p1_,const_iterator_ p2_)
	{
		size_type i = p2_ - p1_;
		size_type n = p_ -ptr_;
		resize(size_ + i);
		if (n != size_)
			memmove(ptr_ + n + i, ptr_ + n, (size_ - n)*sizeof(T));
		for (iterator_ pp_ = ptr_ + n; p1_ != p2_; p1_++,pp_++)
		{
			(void)new (pp_) T(*p1_);
			size_++;
		}
	}

	void push_back(const_reference_ t_)
	{
		resize(size_ + 1);
		(void) new (ptr_ +size_) T(t_);
		size_++;
	}

	reference_ pop_back()
	{	
		return ptr_[size_-- - 1];
	}

	iterator_ erase(iterator_ t_)
	{
		size_type i = t_ - ptr_; 
		if(i >= size_)
			return 0;
		if(t_ != (end()-1))
			memmove(ptr_ + i, (ptr_ + i + 1), (size_ - (i + 1))*sizeof(T));
		size_--;
		return t_;
	}

	//delete all
	void clear()
	{
		if (ptr_)
		{
			for (size_type i = 0; i < size_; i++)
				((iterator_)(ptr_+i))->~T();
			size_ = 0;
			capacity_ = 0;
			::operator delete ((void*)ptr_);
			ptr_ = 0;
		}
	}

	reference_ operator [](size_type n_)
	{
		return (reference_)*(ptr_ + n_);
	}

	iterator_ begin()
	{
		return (iterator_)ptr_;
	}

	iterator_ end()
	{
		return (iterator_)(ptr_ + size_);
	}

	size_type size()
	{
		return size_;
	}

	size_type capacity()
	{
		return capacity_;
	}

	bool empty() const 
	{
		return size_==0;
	}
		

protected:
	//将向量元素个数调整为newsize_，
	//大于向量空间后要重新开辟空间并复制原来的数据到新空间
	void resize(size_type newsize_)
	{
		if(newsize_ <= capacity_)
			return;
		size_type newalloc_ = capacity_ + newsize_; 
		capacity_ = newalloc_;
		void *p= ::operator new(newalloc_ * sizeof(T));
		if(ptr_)
		{
			memcpy(p, ptr_, size_ * sizeof(T));
			::operator delete ((void*)ptr_);
		}
		ptr_ = (iterator_)p;
	}

private:
	iterator_ ptr_;
	size_type capacity_;
	size_type size_;//count of allocated units
};

#endif // !defined(AFX_VECTOR_H__EA7E68E5_F020_4663_B809_9018E0603CBF__INCLUDED_)