#ifndef __VECTOR_H__
#define __VECTOR_H__
template <class Object>
class Vector
{
public:
explicit Vector(int size = 0);//加explicit关键字是为了防止类型的隐式转换
Vector(const Vector &rhs); //拷贝构造函数
~Vector();
const Vector & operator=(const Vector &rhs);//赋值函数
void resize(int newSize); //修改大小
void reserve(int newCapacity); //修改容量
Object & operator[](int index); //重载下标操作符
const Object & operator[](int index) const; //下标操作符重载的重载函数
bool empty() const; //判空
int size() const; //返回大小
int capacity() const; //返回容量
void push_back(const Object &x); //在尾部插入元素
void pop_back(); //删除尾部元素
const Object &back() const; //返回最后一个元素
/* vector类型的迭代器和指针的相似性意味着使用vector而不使用C++
* 数组会导致稍高一点的资源消耗,其缺点是没有错误检测。如果迭代
* itr器冲出了末端标记的话,++itr或*itr都不需要标识错误。解决这
* 个问题需要使iterator和const_iterator是真正的嵌套类类型而不是
* 简单的指针变量。
*/
typedef Object* iterator;
typedef const Object* const_iterator;
iterator begin()
{
return &obj[0];
}
iterator end()
{
return &obj[m_Size];
}
const_iterator begin() const
{
return &obj[0];
}
const_iterator end() const
{
return &obj[m_Size];
}
enum{MIN_CAPACITY = 16};//设置一个枚举来表示最小容量
private:
int m_Size;
int m_Capacity;
Object *obj;
};
template <class Object>
Vector<Object>::Vector(int size = 0)
{
m_Size = size;
m_Capacity = size + MIN_CAPACITY;
obj = new Object[size+MIN_CAPACITY];
}
template<class Object>
Vector<Object>::Vector(const Vector &rhs)
{
m_Size = rhs.m_Size;
m_Capacity = rhs.m_Capacity;
obj = new Object[rhs.m_Capacity];
for(int i=0; i<rhs.m_Capacity; ++i)
{
obj[i] = rhs.obj[i];
}
}
template<class Object>
Vector<Object>::~Vector()
{
delete []obj;
}
template<class Object>
const Vector<Object> &Vector<Object>::operator=(const Vector &rhs)//赋值函数
{
m_Size = rhs.m_Size;
m_Capacity = rhs.m_Capacity;
obj = new Object[rhs.m_Capacity];
for(int i=0; i<rhs.m_Capacity; ++i)
{
obj[i] = rhs.obj[i];
}
return *this;
}
template<class Object>
void Vector<Object>::resize(int newSize)
{
if(newSize > m_Capacity)
{
reserve(2*newSize + 1);//其中一种解决方案,可以有其他不同的写法
}
m_Size = newSize;
}
template<class Object>
void Vector<Object>::reserve(int newCapacity)
{
if(newCapacity < m_Size)
{
return ;
}
else
{
Object *oldObj = obj;
obj = new Object[newCapacity];
for(int i=0; i<m_Size; ++i)
{
obj[i] = oldObj[i];
}
m_Capacity = newCapacity;
delete []oldObj;
}
}
template<class Object>
Object &Vector<Object>::operator[](int index)
{
return obj[index];
}
template<class Object>
const Object &Vector<Object>::operator[](int index) const
{
return obj[index];
}
template<class Object>
bool Vector<Object>::empty() const
{
return (m_Size == 0);
}
template<class Object>
int Vector<Object>::size() const
{
return m_Size;
}
template<class Object>
int Vector<Object>::capacity() const
{
return m_Capacity;
}
template<class Object>
void Vector<Object>::push_back(const Object &x)
{
if(m_Size == m_Capacity)
{
reserve(2*m_Capacity + 1);//其中一种解决方案,可以有其他不同的写法
}
obj[m_Size++] = x;
}
template<class Object>
void Vector<Object>::pop_back()
{
m_Size--;
}
template<class Object>
const Object &Vector<Object>::back() const
{
return obj[m_Size-1];
}
#endif
STL中vector部分功能的实现
最新推荐文章于 2022-04-28 17:38:51 发布