C++模拟实现vector示例代码图文讲解

下面我将给您详细讲解“C++模拟实现vector示例代码”的完整攻略。

1. 什么是Vector

Vector（又称为动态数组）是C++ STL中的一种容器，它可以在运行的过程中自动调整自己的大小，且支持随机访问，其底层是基于数组实现的。

2. 实现Vector的需求

C++中的vector容器具有以下功能：

1. 动态扩容/缩容
2. 随机访问
3. 插入/删除指定位置元素
4. 计算元素数量
5. 支持迭代器等功能

基于以上几点，我们可以初步设想出需要实现以下几个函数：

class Vector{
    public:
        Vector();         // 默认构造函数
        Vector(int size);  // 构造给定大小的vector
        Vector(const Vector& v); // 拷贝构造函数
        Vector& operator=(const Vector& other);  //赋值运算符重载
        ~Vector();   //析构函数
        T& at(int index);  //返回index位置的元素，越界则报错
        void push_back(const T& x); //在数组尾部插入x
        void pop_back();  // 删除末尾元素
        void clear();  // 清空容器
        int size() const; //返回vector的元素数量
        bool empty() const; //判断vector是否为空
};

其中，T是我们定义的模板类，表示vector中存储的数据类型。

3. Vector的实现

构造与析构函数的实现

首先，我们需要为vector定义默认构造函数和析构函数，代码如下：

template<class T>
Vector<T>::Vector(){
    size_ = 0;
    capacity_ = 0;
    data_ = nullptr;
}

template<class T>
Vector<T>::~Vector(){
    clear();
}

其中，size_表示当前vector的元素数量，capacity_表示当前vector的容量，data_表示指向动态数组的指针，而对clear()的调用是确保释放动态数组的内存空间。

其次，我们还需要实现拷贝构造函数和赋值运算符重载：

template<class T>
Vector<T>::Vector(const Vector<T>& v){
    size_ = v.size_;
    capacity_ = v.capacity_;
    data_ = new T[capacity_];
    for(int i = 0; i < size_; i++){
        data_[i] = v.data_[i];
    }
}

template<class T>
Vector<T>& Vector<T>::operator=(const Vector<T>& other){
    if(&other == this){
        return *this;
    }
    clear();
    size_ = other.size_;
    capacity_ = other.capacity_;
    data_ = new T[capacity_];
    for(int i = 0; i < size_; i++){
        data_[i] = other.data_[i];
    }
    return *this;
}

插入/删除指定位置的元素

这个需求比较简单，只需定义如下几个函数：

template<class T>
void Vector<T>::push_back(const T& x){
    if(size_ == capacity_){
        int new_capacity = capacity_ == 0 ? 1 : 2 * capacity_;
        T* new_data = new T[new_capacity];
        for(int i = 0; i < size_; i++){
            new_data[i] = data_[i];
        }
        delete[] data_;
        data_ = new_data;
        capacity_ = new_capacity;
    }
    data_[size_++] = x;
}

template<class T>
void Vector<T>::pop_back(){
    if(size_ == 0){
        return;
    }
    size_--;
}

template<class T>
T& Vector<T>::at(int index){
    if(index < 0 || index > size_ - 1){
        throw std::out_of_range("index out of range");
    }
    return data_[index];
}

在实现push_back()时，需要先判断是否已经达到了初始容量，如果是的话就需要重新开辟一段新空间。

而在实现at()时，需要先进行越界判断，如果下标越界，则会抛出std::out_of_range异常。

计算元素数量

此需求已经在上面的代码中实现，可以直接调用size()函数。

随机访问

这个需求也比较简单，直接定义一个operator[]重载即可：

template<class T>
T& Vector<T>::operator[](int index){
    return at(index);
}

清空容器

这个需求也比较简单，只需定义如下函数：

template<class T>
void Vector<T>::clear(){
    delete[] data_;
    data_ = nullptr;
    size_ = 0;
    capacity_ = 0;
}

示例说明

接下来，我们分别演示一个int类型和一个string类型的vector：

#include<iostream>
#include<string>
#include "vector.h"
using namespace std;

void print_vector(const Vector<int>& v){
    cout << "[";
    for(int i = 0; i < v.size(); i++){
        cout << v[i];
        if(i != v.size() - 1){
            cout << ",";
        }
    }
    cout << "]" << endl;
}

void print_vector(const Vector<string>& v){
    cout << "[";
    for(int i = 0; i < v.size(); i++){
        cout << "\"" << v[i] << "\"";
        if(i != v.size() - 1){
            cout << ",";
        }
    }
    cout << "]" << endl;
}

int main(){
    Vector<int> v1;
    for(int i = 0; i < 10; i++){
        v1.push_back(i + 1);
    }
    print_vector(v1);
    cout << "vector size=" << v1.size() << endl;
    v1.pop_back();
    print_vector(v1);
    cout << "vector size=" << v1.size() << endl;

    Vector<string> v2;
    v2.push_back("hello");
    v2.push_back("world");
    v2.push_back("from");
    v2.push_back("vector");
    print_vector(v2);
    cout << "vector size=" << v2.size() << endl;
}

运行该程序，输出结果如下：

[1,2,3,4,5,6,7,8,9,10]
vector size=10
[1,2,3,4,5,6,7,8,9]
vector size=9
["hello","world","from","vector"]
vector size=4

可见，我们成功地实现了int和string类型的vector，它们拥有动态扩容、随机访问、插入/删除元素、计算元素数量、清空容器等多种功能。