实现一个Vector

意思就是自己用代码模拟Vector向量的使用，包括它的添加数据，删除数据和查询数据方法

#include <algorithm>
#include <iostream>
template <class T>
#define DEFAULT_SIZE 4
class Vector
{
private:
    long size;
    long capacity;
    T *elements;

public:
    // 默认构造函数
    Vector()
    {
        std::cout<<"call default constructor"<<std::endl;
        size = 0;
        capacity = DEFAULT_SIZE;
        elements = new T[capacity];
    }
    // 五大函数
    // 析构函数
    ~Vector()
    {
        std::cout<<"call destructor"<<std::endl;
        size = 0;
        capacity = 0;
        delete[] elements;
    }

    // 拷贝构造函数
    Vector(const Vector &ref) : size{ref.size}, capacity{ref.capacity}
    {
        std::cout <<"call copy constructor"<<std::endl;
        elements = new T[size];
        for (long i = 0; i != size; ++i)
        {
            elements[i] = ref.elements[i];
        }
    }

    // 移动构造函数
    Vector(Vector &&ref) : size{ref.size}, capacity{ref.capacity}, elements{ref.elements}
    {
        std::cout <<"call move constructor"<<std::endl;
        ref.size = 0;
        ref.capacity = 0;
        ref.elements = nullptr;
    }

    // 拷贝赋值
    Vector &operator=(const Vector &ref)
    {
        std::cout <<"call copy assignment"<<std::endl;
        Vector copy = ref;
        // swap会调用一个移动构造，两次移动赋值
        // swap的内部实现如下
        // __glibcxx_function_requires(_SGIAssignableConcept<_Tp>)
        // _Tp __tmp = _GLIBCXX_MOVE(__a);
        // __a = _GLIBCXX_MOVE(__b);
        // __b = _GLIBCXX_MOVE(__tmp);
        std::swap(*this, copy);
        return *this;
    }

    // 移动赋值
    Vector &operator=(Vector &&ref)
    {
        std::cout <<"call move assignment"<<std::endl;
        std::swap(size, ref.size);
        std::swap(capacity, ref.capacity);
        std::swap(elements, ref.elements);
        return *this;
    }

    // 修改size
    void resize(long new_size)
    {
        if (new_size < 0)
        {
            return;
        }
        // 如果容量不够，则开辟更大的内存区域，开辟时保持capacity是size的两倍
        if (new_size > capacity)
        {
            reserve(new_size * 2);
        }
        size = new_size;
    }

    // 修改容量
    void reserve(int new_capacity)
    {
        if (new_capacity <= capacity)
        {
            return;
        }
        T *new_elements = new T[new_capacity];
        for (long i = 0; i != size; ++i)
        {
            new_elements[i] = std::move(elements[i]);
        }
        std::swap(new_elements, elements);
        delete[] new_elements;
        capacity = new_capacity;
    }

    // 重载[]运算符
    T &operator[](long index)
    {
        if (index < 0 || index >= size)
        {
            return nullptr;
        }
        return elements[index];
    }

    // 返回size
    long get_size() const
    {
        return size;
    }

    bool empty() const
    {
        return size == 0;
    }

    void clear()
    {
        std::cout<<"clear"<<std::endl;
        size = 0;
    }

    void push_back(const T &element)
    {
        std::cout<<"call push_back with lvalue"<<std::endl;
        if (size == capacity)
        {
            reserve(size * 2);
        }
        elements[size++] = element;
    }

    void push_back(T &&element){
        std::cout<<"call push_back with rvalue"<<std::endl;
        if (size == capacity)
        {
            reserve(size * 2);
        }
        elements[size++] = std::move(element);
    }

    void pop_back()
    {
        if(size == 0){
            return;
        }
        size--;
    }

    T &back()
    {
        if (size == 0)
        {
            return elements[0];
        }
        return elements[size - 1];
    }

    typedef T *iterator;
    typedef const T *const_iterator;

    iterator begin()
    {
        return &elements[0];
    }

    const_iterator const_begin()
    {
        return &elements[0];
    }

    iterator end()
    {
        return &elements[get_size()];
    }

    const_iterator const_end()
    {
        return &elements[get_size()];
    }
};

template<class T>
void print_vector(Vector<T>& vector);

template<class T>
void print_vector(Vector<T>& vector){
    for(auto it_begin = vector.const_begin(); it_begin != vector.const_end(); ++it_begin)
    {
        std::cout<<"value is "<< *it_begin <<std::endl;
    }
}

int main()
{
    Vector<int> vector1;
    std::cout << "size of vector1 " << vector1.get_size() << std::endl;
    vector1.push_back(1);
    std::cout << "push_back 1" << std::endl;
    std::cout << "size of vector1 " << vector1.get_size() << std::endl;
    int temp = vector1.back();
    vector1.pop_back();
    std::cout << "pop_back" << std::endl;
    std::cout << "value of temp " << temp << std::endl;
    std::cout << "size of vector1 " << vector1.get_size() << std::endl;
    vector1.pop_back();
    std::cout << "pop_back" << std::endl;
    std::cout << "size of vector1 " << vector1.get_size() << std::endl;

    vector1.push_back(1);
    vector1.push_back(2);
    vector1.push_back(3);
    vector1.push_back(4);
    vector1.push_back(5);
    
    const Vector<int> & c_vector1 = vector1;

    print_vector(vector1);
    Vector<int>::iterator iter_begin = vector1.begin();
    *iter_begin = 10;
    std::cout << "change first element of vector1"<< std::endl;
    print_vector(vector1);


    std::cout << "move vector1 to vector2 "  << std::endl;
    Vector<int> vector2;
    vector2 = vector1;
    std::cout << "size of vector1 " << vector1.get_size() << std::endl;
    print_vector(vector1);
    std::cout << "size of vector2 " << vector2.get_size() << std::endl;
    print_vector(vector2);
    vector2.clear();
    vector2.push_back(1);
    const int &lvalue = 2;
    vector2.push_back(lvalue);
    print_vector(vector2);
}

您好，我是有问必答小助手，您的问题已经有小伙伴解答了，您看下是否解决，可以追评进行沟通哦~

如果有您比较满意的答案 / 帮您提供解决思路的答案，可以点击【采纳】按钮，给回答的小伙伴一些鼓励哦～～

ps:问答VIP仅需29元，即可享受5次/月 有问必答服务，了解详情>>>https://vip.csdn.net/askvip?utm_source=1146287632