实现一个简单的vector – turbo_vector

本篇不提供allocator部分

我们需要实现一个模板类，并且提供以下方法和成员

template <typename T>
class turbo_vector
{
public:
    turbo_vector();
    ~turbo_vector();
    void push_back(const T & value);
    void pop_back();
    int size() const;
    int capacity() const;
    void reserve(int size);
    void resize(int size);
    T & at(int index);
    T & front();
    T & back();
    bool empty() const;
    void clear();
    T & operator [] (int index);
    turbo_vector<T> & operator = (const turbo_vector<T> & other);
    T * data();
    void swap(turbo_vector<T> & other);
protected:
    T * data_;     // 记录数组数据
    int size_;     // 记录数组大小
    int capacity_; // 容量，记录数组容量
};

重要函数

push_back

template<typename T>
void turbo_vector<T>::push_back(const T &value)
{
    // 首先我们需要知道当前大小是否超过数组已有空间
    if (size_ < capacity_)
    {
        data_[size_] = value;
        size_++;
        return;
    }
    // 如果超过则扩大数组空间，如果不超过则直接插入数据
    if (capacity_ == 0)
    {
        capacity_ = 1;
    }
    else
    {
        capacity_ *= 2;
    }
    T * data = new T[capacity_];
    if (is_basic_type())
    {
        // 基本类型使用copy速度显著提升
        std::memcpy(data, data_, size_ * sizeof(T));
    }
    else
    {
        // 拷贝原有数据
        for (int i = 0; i < size_; i++)
        {
            data[i] = data_[i];
        }
    }
    // 释放原有空间
    if (data_ != nullptr)
    {
        delete [] data_;
        data_ = nullptr;
    }
    // 插入新数据
    data_ = data;
    data_[size_] = value;
    size_++;
}

reserve

template<typename T>
void turbo_vector<T>::reserve(int size)
{
    // 如果现有空间比size大则不做操作 ,标准库也是这么做的
    if (capacity_ >= size)
    {
        return;
    }
    while (capacity_ < size)
    {
        if (capacity_ == 0)
        {
            capacity_ = 1;
        }
        else
        {
            capacity_ *= 2;
        }
    }
    T * data = new T[capacity_];
    if (is_basic_type())
    {
        std::memcpy(data, data_, size_ * sizeof(T));
    }
    else
    {
        // 拷贝原有数据
        for (int i = 0; i < size_; i++)
        {
            data[i] = data_[i];
        }
    }
    // 释放原有空间并且将使用新空间
    if (data_ != nullptr)
    {
        delete [] data_;
        data_ = nullptr;
    }
    data_ = data;
}

resize

template<typename T>
void turbo_vector<T>::resize(int size)
{
    // size_大则重置
    if (size_ >= size)
    {
        size_ = size;
        return;
    }
    // 如果size大且比空间小，则初始化多余部分
    if (size <= capacity_)
    {
        for (int i = size_; i < size; i++)
        {
            data_[i] = T();
        }
        size_ = size;
        return;
    }
    // 否则扩张初始化新的部分
    while (capacity_ < size)
    {
        if (capacity_ == 0)
        {
            capacity_ = 1;
        }
        else
        {
            capacity_ *= 2;
        }
    }
    T * data = new T[capacity_];
    if (is_basic_type())
    {
        std::memcpy(data, data_, size_ * sizeof(T));
    }
    else
    {
        for (int i = 0; i < size_; i++)
        {
            data[i] = data_[i];
        }
    }
    for (int i = size_; i < size; i++)
    {
        data[i] = T();
    }
    if (data_ != nullptr)
    {
        delete [] data_;
        data_ = nullptr;
    }
    data_ = data;
    size_ = size;
}

at

template<typename T>
T &turbo_vector<T>::at(int index)
{
    // at有异常部分
    if (index < 0 || index >= size_)
    {
        throw std::logic_error("out of range");
    }
    return data_[index];
}

operator=

template<typename T>
turbo_vector<T> &turbo_vector<T>::operator=(const turbo_vector<T> &other)
{
    // 如果capacity() 比新的小则直接全部重建
    if (capacity_ < other.m_size)
    {
        if (data_ != nullptr)
        {
            delete [] data_;
            data_ = nullptr;
            size_ = 0;
            capacity_ = 0;
        }
        while (capacity_ < other.m_size)
        {
            if (capacity_ == 0)
            {
                capacity_ = 1;
            }
            else
            {
                capacity_ *= 2;
            }
        }
        data_ = new T[capacity_];
    }
    if (is_basic_type())
    {
        std::memcpy(data_, other.m_data, size_ * sizeof(T));
    }
    else
    {
        for (int i = 0; i < other.m_size; i++)
        {
            data_[i] = other.m_data[i];
        }
    }
    size_ = other.m_size;
    return *this;
}

swap

template<typename T>
void turbo_vector<T>::swap(turbo_vector<T> &other)
{
    // 传统拷贝
    T * data = other.m_data;
    int size = other.m_size;
    int capacity = other.m_capacity;
    other.m_data = data_;
    other.m_size = size_;
    other.m_capacity = capacity_;
    data_ = data;
    size_ = size;
    capacity_ = capacity;
}

至此基本函数就已经提供完成

迭代器

之后我们还需要提供一个正向的迭代器和一个逆向的迭代器

并且提供迭代器相关的函数

class iterator
{
public:
    iterator() : pointer_(nullptr) {}
    iterator(T * pointer) : pointer_(pointer) {}
    ~iterator() {}
    bool operator == (const iterator & other);
    bool operator != (const iterator & other);
    iterator & operator = (const iterator & other);
    iterator & operator ++ ();
    iterator operator ++ (int);
    iterator operator + (int i);
    iterator & operator += (int i);
    iterator operator - (int i);
    iterator & operator -= (int i);
    int operator - (const iterator & other) const;
    T & operator * ();
    T * operator -> ();
private:
  T * pointer_;
};
class reverse_iterator
{
public:
    reverse_iterator() : pointer_(nullptr) {}
    reverse_iterator(T * pointer) : pointer_(pointer) {}
    ~reverse_iterator() {}
    bool operator == (const reverse_iterator & other);
    bool operator != (const reverse_iterator & other);
    reverse_iterator & operator = (const reverse_iterator & other);
    reverse_iterator & operator ++ ();
    reverse_iterator operator ++ (int);
    reverse_iterator operator + (int i);
    reverse_iterator & operator += (int i);
    reverse_iterator operator - (int i);
    reverse_iterator & operator -= (int i);
    T & operator * ();
    T * operator -> ();
private:
    T * pointer_;
};
reverse_iterator rbegin();
reverse_iterator rend();
iterator begin();
iterator end();
iterator find(const T & value);
iterator rfind(const T & value);
iterator insert(iterator pos, const T & value);
iterator insert(iterator pos, int n, const T & value);
iterator erase(iterator pos);
iterator erase(iterator first, iterator last);
template<typename T>
    typename turbo_vector<T>::reverse_iterator turbo_vector<T>::rbegin()
    {
        turbo_vector<T>::reverse_iterator it(data_ + size_ - 1);
        return it;
    }
template<typename T>
    typename turbo_vector<T>::reverse_iterator turbo_vector<T>::rend()
    {
        turbo_vector<T>::reverse_iterator it(data_ - 1);
        return it;
    }
template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::begin()
    {
        turbo_vector<T>::iterator it(data_);
        return it;
    }
template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::end()
    {
        turbo_vector<T>::iterator it(data_ + size_);
        return it;
    }
template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::find(const T &value)
    {
        for (turbo_vector<T>::iterator it = begin(); it != end(); it++)
        {
            if (*it == value)
            {
                return it;
            }
        }
        return end();
    }
template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::rfind(const T &value)
    {
        for (turbo_vector<T>::reverse_iterator it = rbegin(); it != rend(); it++)
        {
            if (*it == value)
            {
                return turbo_vector<T>::iterator(it.operator->());
            }
        }
        return end();
    }
template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::insert(turbo_vector::iterator pos, const T &value)
    {
        return insert(pos, 1, value);
    }
template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::insert(turbo_vector::iterator pos, int n, const T &value)
    {
        int size = pos - begin();
        if (size_ + n <= capacity_)
        {
            if (is_basic_type())
            {
                std::memmove(data_ + size + n, data_ + size, (size_ - size) * sizeof(T));
            }
            else
            {
                for (int i = size_; i > size; i--)
                {
                    data_[i + n - 1] = data_[i - 1];
                }
            }
            for (int i = 0; i < n; i++)
            {
                data_[size + i] = value;
            }
            size_ += n;
            return turbo_vector<T>::iterator(data_ + size);
        }
        while (size_ + n > capacity_)
        {
            if (capacity_ == 0)
            {
                capacity_ = 1;
            }
            else
            {
                capacity_ *= 2;
            }
        }
        T * data = new T[capacity_];
        if (is_basic_type())
        {
            std::memcpy(data, data_, size * sizeof(T));
        }
        else
        {
            for (int i = 0; i < size; i++)
            {
                data[i] = data_[i];
            }
        }
        for (int i = 0; i < n; i++)
        {
            data[size + i] = value;
        }
        if (is_basic_type())
        {
            std::memcpy(data + size + n, data_ + size, (size_ - size) * sizeof(T));
        }
        else
        {
            for (int i = size; i < size_; i++)
            {
                data[i + n] = data_[i];
            }
        }
        if (data_ != nullptr)
        {
            delete [] data_;
            data_ = nullptr;
        }
        data_ = data;
        size_ += n;
        return turbo_vector<T>::iterator(data_ + size);
    }
template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::erase(turbo_vector::iterator pos)
    {
        if (end() - pos == 1)
        {
            size_ -= 1;
            return end();
        }
        int size = pos - begin();
        if (is_basic_type())
        {
            std::memmove(data_ + size, data_ + size + 1, (size_ - size - 1) * sizeof(T));
        }
        else
        {
            for (int i = size; i < size_ - 1; i++)
            {
                data_[i] = data_[i + 1];
            }
        }
        size_ -= 1;
        return pos;
    }
template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::erase(turbo_vector::iterator first, turbo_vector::iterator last)
    {
        int f = first - begin();
        int l = last - begin();
        int n = last - first;
        if (is_basic_type())
        {
            std::memmove(data_ + f, data_ + l, (size_ - l) * sizeof(T));
        }
        else
        {
            for (int i = 0; i < size_ - l; i++)
            {
                data_[f] = data_[l];
            }
        }
        size_ -= n;
        return first;
    }

全部代码

turbo_vector.h

#ifndef ALGOTEST_TURBO_VECTOR_H
#define ALGOTEST_TURBO_VECTOR_H
#include <type_traits>
#include <typeinfo>
#include <cstring>
#include <stdexcept>
namespace turbo
{
    template <typename T>
    class turbo_vector
    {
    public:
        turbo_vector();
        ~turbo_vector();
        void push_back(const T & value);
        void pop_back();
        int size() const;
        int capacity() const;
        void reserve(int size);
        void resize(int size);
        T & at(int index);
        T & front();
        T & back();
        bool empty() const;
        void clear();
        T & operator [] (int index);
        turbo_vector<T> & operator = (const turbo_vector<T> & other);
        T * data();
        void swap(turbo_vector<T> & other);
        class iterator
        {
        public:
            iterator() : pointer_(nullptr) {}
            iterator(T * pointer) : pointer_(pointer) {}
            ~iterator() {}
            bool operator == (const iterator & other);
            bool operator != (const iterator & other);
            iterator & operator = (const iterator & other);
            iterator & operator ++ ();
            iterator operator ++ (int);
            iterator operator + (int i);
            iterator & operator += (int i);
            iterator operator - (int i);
            iterator & operator -= (int i);
            int operator - (const iterator & other) const;
            T & operator * ();
            T * operator -> ();
        private:
            T * pointer_;
        };
        class reverse_iterator
        {
        public:
            reverse_iterator() : pointer_(nullptr) {}
            reverse_iterator(T * pointer) : pointer_(pointer) {}
            ~reverse_iterator() {}
            bool operator == (const reverse_iterator & other);
            bool operator != (const reverse_iterator & other);
            reverse_iterator & operator = (const reverse_iterator & other);
            reverse_iterator & operator ++ ();
            reverse_iterator operator ++ (int);
            reverse_iterator operator + (int i);
            reverse_iterator & operator += (int i);
            reverse_iterator operator - (int i);
            reverse_iterator & operator -= (int i);
            T & operator * ();
            T * operator -> ();
        private:
            T * pointer_;
        };
        reverse_iterator rbegin();
        reverse_iterator rend();
        iterator begin();
        iterator end();
        iterator find(const T & value);
        iterator rfind(const T & value);
        iterator insert(iterator pos, const T & value);
        iterator insert(iterator pos, int n, const T & value);
        iterator erase(iterator pos);
        iterator erase(iterator first, iterator last);
    protected:
        bool is_basic_type();
    private:
        T * data_{nullptr};     // 记录数组数据
        int size_{0};     // 记录数组大小
        int capacity_{0}; // 容量，记录数组容量
    };
    template<typename T>
    turbo_vector<T>::turbo_vector()
    {
    }
    template<typename T>
    turbo_vector<T>::~turbo_vector()
    {
        if (data_ != nullptr)
        {
            delete [] data_;
            data_ = nullptr;
        }
        size_ = 0;
        capacity_ = 0;
    }
    template<typename T>
    void turbo_vector<T>::push_back(const T &value)
    {
        // 首先我们需要知道当前大小是否超过数组已有空间
        if (size_ < capacity_)
        {
            data_[size_] = value;
            size_++;
            return;
        }
        // 如果超过则扩大数组空间，如果不超过则直接插入数据
        if (capacity_ == 0)
        {
            capacity_ = 1;
        }
        else
        {
            capacity_ *= 2;
        }
        T * data = new T[capacity_];
        if (is_basic_type())
        {
            // 基本类型使用copy速度显著提升
            std::memcpy(data, data_, size_ * sizeof(T));
        }
        else
        {
            // 拷贝原有数据
            for (int i = 0; i < size_; i++)
            {
                data[i] = data_[i];
            }
        }
        // 释放原有空间
        if (data_ != nullptr)
        {
            delete [] data_;
            data_ = nullptr;
        }
        // 插入新数据
        data_ = data;
        data_[size_] = value;
        size_++;
    }
    template<typename T>
    void turbo_vector<T>::pop_back()
    {
        // 直接数据数量操作，不对数组进行操作
        if (size_ > 0)
        {
            size_--;
        }
    }
    template<typename T>
    int turbo_vector<T>::size() const
    {
        return size_;
    }
    template<typename T>
    int turbo_vector<T>::capacity() const
    {
        return capacity_;
    }
    template<typename T>
    void turbo_vector<T>::reserve(int size)
    {
        // 如果现有空间比size大则不做操作 ,标准库也是这么做的
        if (capacity_ >= size)
        {
            return;
        }
        while (capacity_ < size)
        {
            if (capacity_ == 0)
            {
                capacity_ = 1;
            }
            else
            {
                capacity_ *= 2;
            }
        }
        T * data = new T[capacity_];
        if (is_basic_type())
        {
            std::memcpy(data, data_, size_ * sizeof(T));
        }
        else
        {
            // 拷贝原有数据
            for (int i = 0; i < size_; i++)
            {
                data[i] = data_[i];
            }
        }
        // 释放原有空间并且将使用新空间
        if (data_ != nullptr)
        {
            delete [] data_;
            data_ = nullptr;
        }
        data_ = data;
    }
    template<typename T>
    void turbo_vector<T>::resize(int size)
    {
        // size_大则重置
        if (size_ >= size)
        {
            size_ = size;
            return;
        }
        // 如果size大且比空间小，则初始化多余部分
        if (size <= capacity_)
        {
            for (int i = size_; i < size; i++)
            {
                data_[i] = T();
            }
            size_ = size;
            return;
        }
        // 否则扩张初始化新的部分
        while (capacity_ < size)
        {
            if (capacity_ == 0)
            {
                capacity_ = 1;
            }
            else
            {
                capacity_ *= 2;
            }
        }
        T * data = new T[capacity_];
        if (is_basic_type())
        {
            std::memcpy(data, data_, size_ * sizeof(T));
        }
        else
        {
            for (int i = 0; i < size_; i++)
            {
                data[i] = data_[i];
            }
        }
        for (int i = size_; i < size; i++)
        {
            data[i] = T();
        }
        if (data_ != nullptr)
        {
            delete [] data_;
            data_ = nullptr;
        }
        data_ = data;
        size_ = size;
    }
    template<typename T>
    T &turbo_vector<T>::at(int index)
    {
        // at有异常部分
        if (index < 0 || index >= size_)
        {
            throw std::logic_error("out of range");
        }
        return data_[index];
    }
    template<typename T>
    T &turbo_vector<T>::front()
    {
        if (size_ <= 0)
        {
            throw std::logic_error("vector is empty");
        }
        return data_[0];
    }
    template<typename T>
    T &turbo_vector<T>::back()
    {
        if (size_ <= 0)
        {
            throw std::logic_error("vector is empty");
        }
        return data_[size_ - 1];
    }
    template<typename T>
    bool turbo_vector<T>::empty() const
    {
        return size_ == 0;
    }
    template<typename T>
    void turbo_vector<T>::clear()
    {
        size_ = 0;
    }
    template<typename T>
    T &turbo_vector<T>::operator[](int index)
    {
        return at(index);
    }
    template<typename T>
    turbo_vector<T> &turbo_vector<T>::operator=(const turbo_vector<T> &other)
    {
        // 如果capacity() 比新的小则直接全部重建
        if (capacity_ < other.m_size)
        {
            if (data_ != nullptr)
            {
                delete [] data_;
                data_ = nullptr;
                size_ = 0;
                capacity_ = 0;
            }
            while (capacity_ < other.m_size)
            {
                if (capacity_ == 0)
                {
                    capacity_ = 1;
                }
                else
                {
                    capacity_ *= 2;
                }
            }
            data_ = new T[capacity_];
        }
        if (is_basic_type())
        {
            std::memcpy(data_, other.m_data, size_ * sizeof(T));
        }
        else
        {
            for (int i = 0; i < other.m_size; i++)
            {
                data_[i] = other.m_data[i];
            }
        }
        size_ = other.m_size;
        return *this;
    }
    template<typename T>
    T *turbo_vector<T>::data()
    {
        return data_;
    }
    template<typename T>
    void turbo_vector<T>::swap(turbo_vector<T> &other)
    {
        // 传统拷贝
        T * data = other.m_data;
        int size = other.m_size;
        int capacity = other.m_capacity;
        other.m_data = data_;
        other.m_size = size_;
        other.m_capacity = capacity_;
        data_ = data;
        size_ = size;
        capacity_ = capacity;
    }
    template<typename T>
    bool turbo_vector<T>::is_basic_type()
    {
        if (std::is_pointer<T>::value)
        {
            return true;
        }
        return (typeid(T) == typeid(bool))
               || (typeid(T) == typeid(char))
               || (typeid(T) == typeid(unsigned char))
               || (typeid(T) == typeid(short))
               || (typeid(T) == typeid(unsigned short))
               || (typeid(T) == typeid(int))
               || (typeid(T) == typeid(unsigned int))
               || (typeid(T) == typeid(long))
               || (typeid(T) == typeid(unsigned long))
               || (typeid(T) == typeid(float))
               || (typeid(T) == typeid(double));
    }
    template<typename T>
    typename turbo_vector<T>::reverse_iterator turbo_vector<T>::rbegin()
    {
        turbo_vector<T>::reverse_iterator it(data_ + size_ - 1);
        return it;
    }
    template<typename T>
    typename turbo_vector<T>::reverse_iterator turbo_vector<T>::rend()
    {
        turbo_vector<T>::reverse_iterator it(data_ - 1);
        return it;
    }
    template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::begin()
    {
        turbo_vector<T>::iterator it(data_);
        return it;
    }
    template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::end()
    {
        turbo_vector<T>::iterator it(data_ + size_);
        return it;
    }
    template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::find(const T &value)
    {
        for (turbo_vector<T>::iterator it = begin(); it != end(); it++)
        {
            if (*it == value)
            {
                return it;
            }
        }
        return end();
    }
    template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::rfind(const T &value)
    {
        for (turbo_vector<T>::reverse_iterator it = rbegin(); it != rend(); it++)
        {
            if (*it == value)
            {
                return turbo_vector<T>::iterator(it.operator->());
            }
        }
        return end();
    }
    template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::insert(turbo_vector::iterator pos, const T &value)
    {
        return insert(pos, 1, value);
    }
    template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::insert(turbo_vector::iterator pos, int n, const T &value)
    {
        int size = pos - begin();
        if (size_ + n <= capacity_)
        {
            if (is_basic_type())
            {
                std::memmove(data_ + size + n, data_ + size, (size_ - size) * sizeof(T));
            }
            else
            {
                for (int i = size_; i > size; i--)
                {
                    data_[i + n - 1] = data_[i - 1];
                }
            }
            for (int i = 0; i < n; i++)
            {
                data_[size + i] = value;
            }
            size_ += n;
            return turbo_vector<T>::iterator(data_ + size);
        }
        while (size_ + n > capacity_)
        {
            if (capacity_ == 0)
            {
                capacity_ = 1;
            }
            else
            {
                capacity_ *= 2;
            }
        }
        T * data = new T[capacity_];
        if (is_basic_type())
        {
            std::memcpy(data, data_, size * sizeof(T));
        }
        else
        {
            for (int i = 0; i < size; i++)
            {
                data[i] = data_[i];
            }
        }
        for (int i = 0; i < n; i++)
        {
            data[size + i] = value;
        }
        if (is_basic_type())
        {
            std::memcpy(data + size + n, data_ + size, (size_ - size) * sizeof(T));
        }
        else
        {
            for (int i = size; i < size_; i++)
            {
                data[i + n] = data_[i];
            }
        }
        if (data_ != nullptr)
        {
            delete [] data_;
            data_ = nullptr;
        }
        data_ = data;
        size_ += n;
        return turbo_vector<T>::iterator(data_ + size);
    }
    template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::erase(turbo_vector::iterator pos)
    {
        if (end() - pos == 1)
        {
            size_ -= 1;
            return end();
        }
        int size = pos - begin();
        if (is_basic_type())
        {
            std::memmove(data_ + size, data_ + size + 1, (size_ - size - 1) * sizeof(T));
        }
        else
        {
            for (int i = size; i < size_ - 1; i++)
            {
                data_[i] = data_[i + 1];
            }
        }
        size_ -= 1;
        return pos;
    }
    template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::erase(turbo_vector::iterator first, turbo_vector::iterator last)
    {
        int f = first - begin();
        int l = last - begin();
        int n = last - first;
        if (is_basic_type())
        {
            std::memmove(data_ + f, data_ + l, (size_ - l) * sizeof(T));
        }
        else
        {
            for (int i = 0; i < size_ - l; i++)
            {
                data_[f] = data_[l];
            }
        }
        size_ -= n;
        return first;
    }
    template<typename T>
    bool turbo_vector<T>::iterator::operator==(const turbo_vector::iterator &other)
    {
        return pointer_ == other.pointer_;
    }
    template<typename T>
    bool turbo_vector<T>::iterator::operator!=(const turbo_vector::iterator &other)
    {
        return pointer_ != other.pointer_;
    }
    template<typename T>
    typename turbo_vector<T>::iterator &turbo_vector<T>::iterator::operator=(const turbo_vector::iterator &other)
    {
        pointer_ = other.pointer_;
        return *this;
    }
    template<typename T>
    typename turbo_vector<T>::iterator &turbo_vector<T>::iterator::operator++()
    {
        pointer_ += 1;
        return *this;
    }
    template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::iterator::operator++(int)
    {
        iterator it = *this;
        ++(*this);
        return it;
    }
    template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::iterator::operator+(int i)
    {
        iterator it = *this;
        it.pointer_ += i;
        return it;
    }
    template<typename T>
    typename turbo_vector<T>::iterator &turbo_vector<T>::iterator::operator+=(int i)
    {
        pointer_ += i;
        return *this;
    }
    template<typename T>
    typename turbo_vector<T>::iterator turbo_vector<T>::iterator::operator-(int i)
    {
        iterator it = *this;
        it.pointer_ -= i;
        return it;
    }
    template<typename T>
    typename turbo_vector<T>::iterator &turbo_vector<T>::iterator::operator-=(int i)
    {
        pointer_ -= i;
        return *this;
    }
    template<typename T>
    int turbo_vector<T>::iterator::operator-(const turbo_vector::iterator &other) const
    {
        return pointer_ - other.pointer_;
    }
    template<typename T>
    T &turbo_vector<T>::iterator::operator*()
    {
        return *pointer_;
    }
    template<typename T>
    T *turbo_vector<T>::iterator::operator->()
    {
        return pointer_;
    }
    template<typename T>
    bool turbo_vector<T>::reverse_iterator::operator==(const turbo_vector::reverse_iterator &other)
    {
        return pointer_ == other.pointer_;
    }
    template<typename T>
    bool turbo_vector<T>::reverse_iterator::operator!=(const turbo_vector::reverse_iterator &other)
    {
        return pointer_ != other.pointer_;
    }
    template<typename T>
    typename turbo_vector<T>::reverse_iterator & turbo_vector<T>::reverse_iterator::operator=(const turbo_vector::reverse_iterator &other)
    {
        pointer_ = other.pointer_;
        return *this;
    }
    template<typename T>
    typename turbo_vector<T>::reverse_iterator &turbo_vector<T>::reverse_iterator::operator++()
    {
        pointer_ -= 1;
        return *this;
    }
    template<typename T>
    typename turbo_vector<T>::reverse_iterator turbo_vector<T>::reverse_iterator::operator++(int)
    {
        reverse_iterator it = *this;
        ++(*this);
        return it;
    }
    template<typename T>
    typename turbo_vector<T>::reverse_iterator turbo_vector<T>::reverse_iterator::operator+(int i)
    {
        reverse_iterator it = *this;
        it.pointer_ -= i;
        return it;
    }
    template<typename T>
    typename turbo_vector<T>::reverse_iterator &turbo_vector<T>::reverse_iterator::operator+=(int i)
    {
        pointer_ -= i;
        return *this;
    }
    template<typename T>
    typename turbo_vector<T>::reverse_iterator turbo_vector<T>::reverse_iterator::operator-(int i)
    {
        reverse_iterator it = *this;
        it.pointer_ += i;
        return it;
    }
    template<typename T>
    typename turbo_vector<T>::reverse_iterator &turbo_vector<T>::reverse_iterator::operator-=(int i)
    {
        pointer_ += i;
        return *this;
    }
    template<typename T>
    T &turbo_vector<T>::reverse_iterator::operator*()
    {
        return *pointer_;
    }
    template<typename T>
    T *turbo_vector<T>::reverse_iterator::operator->()
    {
        return pointer_;
    }
}
#endif //ALGOTEST_TURBO_VECTOR_H

实现一个简单的vector

实现一个简单的vector – turbo_vector

重要函数

push_back

reserve

resize

at

operator=

swap

迭代器

全部代码

热门文章

最新文章

相关电子书