vector第二步修炼之道

在上一篇博客中，我们使用STL库中的vector简单的使用了它，那么我们学习了面向对象的知识，为何不写一个vector 类呢？
首先需要定义成员变量：包括一个指向vector首元素的指针，数组的长度，数组的有效元素长度，还有一个扩展内存。
成员方法：构造函数，拷贝构造，赋值函数，外加相应的操纵函数。

定义vector.h文件

#pragma once
#include<iostream>
using namespace std;
template<typename  E>
class vector
{
public:
    //默认构造函数，所有成员都给默认的零值
    vector(int initialsize = 0);
    //num:初始元素的个数，value表示初始元素的值
    vector(int num, E value);
    //用[first, last)区间的元素初始化当前容器
    vector(E *first, E *last);
    //析构函数
    ~vector();
    //拷贝构造函数
    vector(const vector&src);
    //赋值运算符的重载函数
    void operator=(const vector&src);
    //向容器的末尾添加新元素value，若增长内存，调用resize函数
    void push_back(const E &value);
    //删除容器末尾的元素
    void pop_back();
    //查找某个元素的地址
    E* getpos(int val);
    //向指定位置pos插入新元素value，若增长内存，调用resize函数
    void insert(E *pos, const E &value);

    //删除指定位置的元素
    void erase(E *pos);
    //打印容器有效元素值的函数
    void show()const;
    //判断容器是否空
    bool empty()const;
    //判断容器是否满
    bool full()const;
private:
    //内存增长函数，按原有容量的两倍增长
    void resize()
    {
        if (_end == 0)//默认构造vector;
        {
            _end = 1;
            _first = new E[_end];
        }
        else
        {
            E *_newfirst = new E[_end * 2];
            for (int i = 0; i < _end; i++)
            {
                _newfirst[i] = _first[i];
            }
            _end *= 2;
            delete[]_first;
            _first = _newfirst;
        }
    }
    E *_first;   //存储放入容器的元素
    int _end;      //_element数组的总容量
    int _last;     //_element有效元素的个数
};
//默认构造函数，所有成员都给默认的零值
template <typename E>
vector<E>::vector(int initialsize=0)
    :_last(0), _end(initialsize)
{   
    if (initialsize==0)
    {
        _first = NULL;
    }
    else
    {
        _first = new E(_end);
    }
}
//num:初始元素的个数，value表示初始元素的值
template <typename E>
vector<E>::vector(int num,E value)
    :_end(num),_last(num)
{
    _first = new E[num];
    for (int i = 0; i < _end; i++)
    {
        _first[i] = value;
    }
}
//用[first, last)区间的元素初始化当前容器
template <typename E>
vector<E>::vector(E *first, E *last)
{
    int size = *last - *first;
    _first = new E[size];
    _end = _last = size;
    for (int i = 0; i < size; i++)
    {
        _first[i] = (*first)++;
    }
}
//析构函数
template <typename E>
vector<E>::~vector()
{
    if (_first!=NULL)
    {
        delete[] _first;        
    }
}
//拷贝构造函数
template <typename E>
vector<E>::vector(const vector &src)
{
    _end = src._end;
    _first = new E[_end];
    _last = src._last;
    for (int i = 0; i < _last; i++)
    {
        _first[i] = (src._first)[i];
    }
}
//赋值运算符的重载函数
template <typename E>
void vector<E>::operator=(const vector &src)
{
    if (this == &src)
    {
        return;
    }
    delete[]_first;

    _end = src._end;
    _first = new E[_end];
    _last = src._last;
    for (int i = 0; i < _last; i++)
    {
        _first[i] = (src._first)[i];
    }
}
//向容器的末尾添加新元素value，若增长内存，调用resize函数
template <typename E>
void vector<E>::push_back(const E &value)
{
    if(full())
    { 
        resize();
    }
    _first[_last++] = value;
}
//删除容器末尾的元素
template <typename E>
void vector<E>::pop_back()
{
    if (!empty())
    {
        _last--;    
    }
}
// vector 元素的位置
template <typename E>
E* vector<E>::getpos(int val)
{
    for (int i = 0; i < _end; i++)
    {
        if (_first[i] == val)
        {
            return &(_first[i]);
        }
    }
    return NULL;
}

//向指定位置pos插入新元素value，若增长内存，调用resize函数
template <typename E>
void vector<E>::insert(E *pos, const E &value)
{
    int index = pos - _first;
    if (index<0 || index>_last)
    {
        printf("error");
        return;
    }
    if (full())
    {
        resize();
    }
    if (index < _last)
    {
        for (int i = _last; i > index; --i)
        {
            _first[i] = _first[i-1];   
        }
    }
    _first[index] = value;
    _last++;
}

//删除指定位置的元素
template <typename E>
void vector<E>::erase(E *pos)
{
    int index = pos - _first;
    if (index<0 || index>_last)
    {
        printf("error");
        return;
    }
    if (!empty())
    {   
        for (int i = index; i < _last; i++)
        {
            _first[i] = _first[i + 1];
        }           
        _first[_last] = E();
        _last--;        
    }   
}
//打印容器有效元素值的函数
template <typename E>
void vector<E>::show()const
{
    if (_first!=NULL)
    {
        for (int i = 0; i < _last; i++)
        {
            cout << _first[i] ;
        }
        cout << endl;
    }
}
//判断容器是否空
template <typename E>
bool vector<E>::empty()const
{ 
    if (_last==0)
    {
        return true;
    }
    else
    {
        return false;
    }
}
//判断容器是否满
template <typename E>
bool vector<E>::full()const
{
    if (_last==_end)
    {
        return true;
    }
    else
    {
        return false;
    }
}

测试函数

#include<iostream>
#include "vector.h"

using namespace std;


int main()
{
    vector<int> vec1(10);   //默认构造
    vector<int> vec2(10,1);   
    vec2.show();
    int m = 1;
    int n = 5;
    vector<int> vec3(&m, &n);
    vec3.show();
    vector<int> vec4(vec3);  //拷贝构造
    vec4.show();
    vector<int> vec5=vec3;   //赋值构造
    vec5.show();
    vec5.push_back(6);
    vec5.show();
    vec5.pop_back();
    vec5.show();
    if ((vec5.getpos(1))!=NULL)
    {
        vec5.insert(vec5.getpos(1),7);
        vec5.show();
    }
    vec5.erase(vec5.getpos(7));
    vec5.show();
    return 0;
}