c++ 基础类 - Vector 类

Vector 类

常用的成员函数

DataType operator[] (size_t i);
size_t Size();
size_t Capacity();
DataType *begin();
DataType *end();
void PushBack(DataType x);
void PopBack();
void Reserve(size_t n);
void Insert(DataType *pos, const DataType &val);
void Erase(DataType *pos);
size_t Find(DataType x);
bool Empty();

1. 构造

// 1.构造
Vector(size_t n = 3) // 初始给 3 个元素的容量
    : _first(new DataType(n)),
      _finish(_first),
      _endofstorage(_first + n)
{}

2. 拷贝构造

// 2.拷贝构造
Vector(const Vector &v)
{
    if(v._finish - v._first > _finish - _first)
    {
        delete[] _first;
        _first = new DataType[v._finish - v._first];
        _finish = _first;
    }
    for(DataType *tmp = v. _first; tmp != v._finish; tmp++) // 从 v 的first遍历到finish
    {
        *_finish = *tmp;
        _finish++;
    }
    _endofstorage = _finish;
}

3.赋值操作符重载

// 3.赋值操作符的重载
Vector &operator= (Vector &v)
{
    if(this != &v)
    {
        swap(_first, v._first);
        swap(_finish, v._finish);
        swap(_endofstorage, v._endofstorage);
    }
    return *this;
}

4.析构

// 4.析构
~Vector()
{
    if(_first)
    {
        delete[] _first;
    }
    _first = NULL;
    _finish = NULL;
    _endofstorage = NULL;
}

实现代码

#pragma once

#include <iostream>
#include <algorithm>
#include <stdio.h>

using namespace std;

typedef int DataType;

class Vector
{
public:
    // 1.构造
    Vector(size_t n = 3) // 初始给 3 个元素的容量
        : _first(new DataType(n)),
          _finish(_first),
          _endofstorage(_first + n)
    {}
    // 2.拷贝构造
    Vector(const Vector &v)
    {
        if(v._finish - v._first > _finish - _first)
        {
            delete[] _first;
            _first = new DataType[v._finish - v._first];
            _finish = _first;
        }
        for(DataType *tmp = v. _first; tmp != v._finish; tmp++) // 从 v 的first遍历到finish
        {
            *_finish = *tmp;
            _finish++;
        }
        _endofstorage = _finish;
    }

    // 3.赋值操作符的重载
    Vector &operator= (Vector &v)
    {
        if(this != &v)
        {
            swap(_first, v._first);
            swap(_finish, v._finish);
            swap(_endofstorage, v._endofstorage);
        }
        return *this;
    }

    // 4.析构
    ~Vector()
    {
        if(_first)
        {
            delete[] _first;
        }
        _first = NULL;
        _finish = NULL;
        _endofstorage = NULL;
    }
    // 5.随机访问 [] 重载
    DataType operator[] (size_t i)
    {
        return _first[i];
    }
    size_t Size();
    size_t Capacity();
    DataType *begin();
    DataType *end();
    void PushBack(DataType x);
    void PopBack();
    void Reserve(size_t n);
    void Insert(DataType *pos, const DataType &val);
    void Erase(DataType *pos);
    size_t Find(DataType x);
    bool Empty();
private:
    void checkCapacity(); // 检查容量, 扩容

    DataType *_first; // 数据存放开始的位置
    DataType *_finish; // 数据存放结束的位置 + 1
    DataType *_endofstorage; // 容量的最后一个位置
};

#include "vector.h"

// 计算大小
size_t Vector::Size()
{
    return _finish - _first;
}
// 判空
bool Vector::Empty()
{
    return _first == _finish;
}
// 迭代器
DataType *Vector::begin()
{
    return _first;
}
DataType *Vector::end()
{
    return _finish;
}
// 计算容量
size_t Vector::Capacity()
{
    return _endofstorage - _first;
}
// 尾插
void Vector::PushBack(DataType x)
{
    checkCapacity();
    Insert(end(), x);
}
// 尾删
void Vector::PopBack()
{
    DataType *pos = end();
    Erase(--pos);
}
// 一次开指定大小的空间
void Vector::Reserve(size_t n)
{
    if(n > Capacity())
    {
        DataType *new_first = new DataType[n];
        DataType *new_finish = new_first;
        for(DataType *tmp = begin(); tmp != end(); tmp++)
        {
            *new_first = *tmp;
            new_finish++;
        }
        delete[] _first;
        _first = new_first;
        _finish = new_finish;
        _endofstorage = n + _first;
    }
}
// 插入
void Vector::Insert(DataType *pos, const DataType &val)
{
    checkCapacity();
    for(DataType *tmp = end(); tmp != pos; --tmp)
    {
        *tmp = *(tmp - 1);
    }
    *pos = val;
    _finish++;
}
// 删除
void Vector::Erase(DataType *pos)
{
    DataType *end_pos = end();
    for(DataType *tmp = pos; tmp != (--end_pos); tmp++)
    {
        *tmp = *(tmp + 1);
    }
    --_finish;
}
// 查找
size_t Vector::Find(DataType x)
{
    for(size_t i = 0; i < Size(); i++)
    {
        if(_first[i] == x)
        {
            return i;
        }
    }
    return -1;
}
// 检查容量, 扩容
void Vector::checkCapacity()
{
    if(_finish == _endofstorage)
    {
        DataType *new_first = new DataType[Size() * 2]; // 一次扩容至两倍
        DataType *new_finish = new_first;
        size_t size = Size();
        for(size_t i = 0; i < size; i++) // 把旧的先拷贝过来
        {
            new_first[i] = _first[i];
            new_finish++;
        }
        delete[] _first; // 释放旧的
        _first = new_first;
        _finish = new_finish;
        _endofstorage = _first + Size() * 2;
    }
}

测试代码

#include "vector.h"


void Test01()
{
    Vector v;
    int size = v.Size(); // 测试当前大小
    int capacity = v.Capacity(); // 测试容量
    cout << size << endl;
    cout << capacity << endl;
}

void Test02()
{
    Vector v;
    v.PushBack(1);
    v.PushBack(3);
    v.PushBack(7);
    v.PushBack(9);
    for(size_t i = 0; i < v.Size(); i++)
    {
        cout << v[i] << endl;
    }
    size_t pos = v.Find(5);
    cout << "size ecpected : 4 , actual : " << v.Size() << endl;
    cout << "capacity ecpected : 6 , actual : " << v.Capacity() << endl;
    v.PopBack();
    cout << "size ecpected : 3 , actual : " << v.Size() << endl;
    cout << "capacity ecpected : 6 , actual : " << v.Capacity() << endl;
}

void Test03()
{
    Vector v1;
    v1.Reserve(100);
    size_t capacity = v1.Capacity();
    cout << "capacity change : " << v1.Capacity() << endl;
    for(int i = 0; i < 100; i++)
    {
        v1.PushBack(i);
        if(v1.Capacity() != capacity)
            cout << "capacity change : " << v1.Capacity() << endl;
    }
    Vector v2;
    size_t capa = v2.Capacity();
    for(int i = 0; i < 100; i++)
    {
        v2.PushBack(i);
        if(v2.Capacity() != capa)
            cout << "capacity change : " << v2.Capacity() << endl;
    }
}

void Test04()
{
    Vector vc;
    vc.PushBack(1);
    vc.PushBack(3);
    vc.PushBack(5);
    vc.PushBack(7);
    for(size_t i = 0; i < vc.Size(); i++)
    {
        cout << vc[i] << endl;
    }
    size_t pos = vc.Find(5);
    cout << "pos : " << pos << endl;
    Vector vc1;
    vc1.PushBack(2);
    vc1.PushBack(4);
    vc1.PushBack(6);
    vc1.PushBack(8);
    for(size_t i = 0; i < vc1.Size(); i++)
    {
        cout << vc1[i] << endl;
    }
    vc1 = vc;
    for(size_t i = 0; i < vc1.Size(); i++)
    {
        cout << vc1[i] << endl;
    }
    for(size_t i = 0; i < vc.Size(); i++)
    {
        cout << vc[i] << endl;
    }
}

void Test05()
{
    Vector vc;
    vc.PushBack(1);
    vc.PushBack(1);
    vc.PushBack(1);
    vc.PushBack(1);
    vc.PopBack();
    vc.PopBack();
    vc.PopBack();
    vc.PopBack();
    if(vc.Empty())
    {
        cout << "Vector 为空" << endl;
    }
    else
    {
        cout << "Vector 不为空" << endl;
    }
}

int main()
{
    printf("\n\n\n");
    printf("\n\n\n");
    //    Test01();
    //    Test02();
    //    Test03();
    //    Test04();
    Test05();
    printf("\n\n\n");
    printf("\n\n\n");
    return 0;
}