C++ 面向对象-向量类模板的实现（实验）

向量类模板是STL中的一种线性容器，提供了线性连续存储的动态数据结构。可以通过下标运算符快熟访问容器中的任一个元素，就像内置数组类型一样。同时，当向量中的存储空间用完后，还可以扩充容量。

任务描述

向量类模板的实现。

相关知识

为了完成本关任务，你需要：
1.理解STL中容器的概念。
2.数组的基本操作。如数组元素的随机访问、基于指针的元素的插入、基于指针的元素的删除。
3.理解迭代器的概念，如何针对不同的容器实现其迭代器。
4.基于函数模板的通用算法的实现。

编程要求

根据提示，在右侧编辑器补充代码，完成向量类模板的成员函数的功能。

测试说明

平台会对你编写的代码进行测试：

测试输入：无；
预期输出：
The original numbers are:
0 1 2 3 4 5 6 7 8 9
after erasing the first:
1 2 3 4 5 6 7 8 9
after insert 999:
1 2 3 999 4 5 6 7 8 9
The elements in Vector V1 are:
2 3 4 1000 5 6 7 8 9 10 6 6 6 6 6
The elements in Vector V2 are:
2 3 4 1000 5 6 7 8 9 10 6 6 6 6

Vector.h

#pragma once
template <typename T>
class Vector

{
private:
	T* data;
	int size;
	int max;
public:
	enum { SPARE_MAX = 3 };  //此处将最大值改小点，测试代码的问题。
	explicit Vector(int n = 0) :size(0), max(n + SPARE_MAX)
	{
		data = new T[max];
	}

	Vector(const Vector& v)
	{
		*this = v;
	}

	~Vector() { delete[] data; }

	Vector& operator=(const Vector& v);

	T& operator[](int id) { return data[id]; }
	const T& operator[](int id) const { return data[id]; }

	bool Empty() const { return size == 0; }
	int Size() const{ return size; }
	int Max() const { return max; }
	void Clear() { size = 0; }

	typedef T* iterator;     //迭代器
	typedef const T* const_iterator;    //常量型迭代器
	iterator Begin() { return data; }
	const_iterator Begin() const { return data; }
	iterator End() { return data + size; }
	const_iterator End() const{ return data + size; }

	T& Front() { return data[0]; }
	const T& Front() const { return data[0]; }
	T& Back() { return data[size - 1]; }
	const T& Back() const { return data[size - 1]; }

	void Push_back(const T& item);
	void Pop_back()
	{
		if (!Empty()) size--;
	}

	void Reserve(int newMax);  //扩大数组容量为newMax，并保留原来的数据
	void Resize(int newSize, const T& item = T());   //把数据个数增加为newSize,保留原来的数据，其余的值为item

	iterator Insert(iterator itr, const T& item = T()); //在itr所指向的位置插入item
	iterator Erase(iterator itr); //删除itr所指向的元素
};

代码段的实现：

//赋值运算符重载
/************Begin***********************/
template <typename T>
Vector<T> &Vector<T>::operator=(const Vector<T> &v)
{
    size = v.size;
    max = v.max;
    if (data)
    {
        delete[] data;//此处是应该delete一次的，但是由于在题目给的复制构造函数之中，
                      //没有进行一步初始化，所以delete[] data 可能会导致在平台上编译不通过
    }
    data = new T[max]();
    for (int i = 0; i < size; i++)
    {
        data[i] = v.data[i];
    }
    return *this;
}
/************End*************************/

//尾部插入数据
/************Begin***********************/
template <typename T>
void Vector<T>::Push_back(const T &item)
{
    size++;
    if (size == max)
    {
        Reserve(max + SPARE_MAX);
    }
    data[size - 1] = item;
}
/************End*************************/

//扩大数组容量为newMax，并保留原来的数据
/************Begin***********************/
template <class T>
void Vector<T>::Reserve(int newMax) //扩大数组容量为newMax，并保留原来的数据
{
    max = newMax;
    T *temp = new T[max]();
    for (int i = 0; i < size; ++i)
    {
        temp[i] = data[i];
    }
    delete[] data;
    data = temp;
}
/************End*************************/

//把数据个数增加为newSize,保留原来的数据，其余的值为item
/************Begin***********************/
template <class T>
void Vector<T>::Resize(int newSize, const T &item)
{
    int n = newSize - size;
    for (int i = 0; i < n; ++i)
    {
        Push_back(item);
    }
}
/************End*************************/

//基于指针插入数据
/************Begin***********************/
template <class T>
typename Vector<T>::iterator Vector<T>::Insert(typename Vector<T>::iterator itr, const T &item)
{
    Push_back(*(End() - 1));
    for (typename Vector<T>::iterator ptr = End() - 1; ptr != itr; --ptr)
    {
        *ptr = *(ptr - 1);
    }
    *itr = item;
    return itr;
}
/************End*************************/

//基于指针删除数据
/************Begin***********************/
template <class T>
typename Vector<T>::iterator Vector<T>::Erase(iterator itr)
{
    for (typename Vector<T>::iterator ptr = itr; (ptr + 1) != End(); ++ptr)
    {
        *ptr = *(ptr + 1);
    }
    size--;
    return itr;
}
/************End*************************/

main.cpp

题目测试的代码

int main()
{
    //第1部分测试:constructor,Insert,Erase
    Vector<int> V;
    for (int i = 0; i < 10; i++)
    {
        V.Push_back(i);
    }
    cout << "The original numbers are:" << endl;
    display_vector(V.Begin(), V.End());

    Vector<int>::iterator itr = V.Begin(); //取首元素指针
    V.Erase(itr);                          //删除第一个元素
    cout << "after erasing the first:" << endl;
    display_vector(V.Begin(), V.End());

    itr += 3;
    V.Insert(itr, 999);
    cout << "after insert 999:" << endl;
    display_vector(V.Begin(), V.End());

    //第2部分测试:copyconstructor,operator=,Resize,operator[]
    Vector<int> V1(V); //复制构造
    V1.print();
    V1.Resize(15, 5);
    for (int i = 0; i < V1.Size(); i++)
        V1[i]++;
    cout << "The elements in Vector V1 are:" << endl;
    display_vector(V1.Begin(), V1.End());

    Vector<int> V2;
    V2 = V1;
    itr = V2.End();
    itr--;
    V2.Erase(itr);
    cout << "The elements in Vector V2 are:" << endl;
    display_vector(V2.Begin(), V2.End());

    return 0;
}

 运行的结果：

The original numbers are:
0 1 2 3 4 5 6 7 8 9 
after erasing the first:
1 2 3 4 5 6 7 8 9 
after insert 999:
1 2 3 999 4 5 6 7 8 9 
The elements in Vector V1 are:
2 3 4 1000 5 6 7 8 9 10 6 6 6 6 6 
The elements in Vector V2 are:
2 3 4 1000 5 6 7 8 9 10 6 6 6 6 

代码中也许还有很多不好的地方

HBUT duxingmengshou