从零开始vector的C++模拟实现

最新推荐文章于 2024-07-10 22:49:54 发布

dao_shadow

最新推荐文章于 2024-07-10 22:49:54 发布

阅读量373

点赞数 5

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/dao_shadow/article/details/139185001

版权

一、vector的认识

C++ 中的 vector 是一种序列容器，它允许你在运行时动态地插入和删除元素。 vector 是基于数组的数据结构，但它可以自动管理内存，这意味着你不需要手动分配和释放内存。与 C++ 数组相比，vector 具有更多的灵活性和功能，使其成为 C++ 中常用的数据结构之一。

vector的数据成员：

iterator _start;		// 指向数据块的开始
iterator _finish;		// 指向有效数据的尾下一个位置
iterator _endofstorage;  // 指向存储容量的尾下一个位置

_start是指向首地址的迭代器，_finish是指向有效数据末尾的下一个位置的迭代器，而_endOfStorage是指向总容量的最后的下一个位置的迭代器。其中iterator和const_iterator的定义为

typedef T* iterator;   //迭代器
typedef const T* const_iterator;  //const类型的迭代器

二、数据成员的声明


        iterator _start; 

        iterator _finish; 

        iterator _endofstorage;

三、构造函数，析构函数和拷贝构造函数

3.1无参构造

vector()
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{}

3.2带参缺省参数构造

vector(size_t n, const T& value = T())
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
            reserve(n);//调整内存
            for (int i = 0; i < n; i++)
            {
                _start[i] = value;
            }
            _finish = _start + n;//调整迭代器

}

也可以写成下面这样：

vector(size_t n, const T& value = T())
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
	reserve(n);
	for (size_t i = 0;i < n;i++)
	{
		push_back(value);
	}
}

第二个参数const T& value = T()，T（）是一个临时对象并且它没有名字（即匿名对象），我们前面用value引用，后面的匿名对象赋值的中间临时变量赋值给value，因为临时对象具有常性，所以这里我们在参数中应该用const修饰.

不过此处为了与迭代区间构造区分，不使编译器错误调用，我们应该再实现一个int类型的构造

例如：

vector(int n, const T& value = T())
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
	reserve(n);
	for (int i = 0;i < n;i++)
	{
		push_back(value);
	}
}

3.3迭代器区间构造

 template<class InputIterator>
 //支持任意容器的迭代器区间初始化
 vector(InputIterator first, InputIterator last)
	:_start(nullptr)
	, _finish(nullptr)
	, _endOfStorage(nullptr)
 {
     while (first != last)
     {
         push_back(*first);
         ++first;
     }
 }

3.4拷贝构造函数

vector(const vector<T>& v)
    :_start(nullptr)
	, _finish(nullptr)
	, _endOfStorage(nullptr)
{
    T* tmp = new T[v.capacity()];
    _start = tmp;
    _finish = tmp + v.size();
    _endofstorage = tmp+v.capacity();
    for (int i = 0; i < v.size(); i++)
    {
        _start[i] = v._start[i];
    }
   
}

拷贝构造函数需要在起始位置开一个空间和v一样大小的空间即可，然后把v中的数据一个一个拷贝过去。（深拷贝）因为当vector中储存的是自定义类型时，进行浅拷贝只是简单的字节拷贝，会析构两次，程序崩溃。

3.5析构函数

~vector()
{
	delete[] _start;
	_start = _finish = _endofstorage = nullptr;
}

3.6赋值拷贝

            vector<T>& operator= (vector<T> v)
            {
                swap(v);
                return *this;
            }

四、成员函数

4.1迭代器

提供iterator和const_iterator两个版本


        iterator begin()
        {
            return _start;
        }

        iterator end()
        {
            return _finish;
        }

        const_iterator begin() const
        {
            return _start;
        }

        const_iterator end() const
        {
            return _finish;
        }

4.2size()和capacity()


        size_t size() const
        {
            return _finish - _start;
        }

        size_t capacity() const
        {
            return _endofstorage - _start;
        }

4.3reserve()

void reserve(size_t n)
{
    if (n > capacity())
    {
        size_t oldsize = size();//因为扩容可能会迭代器失效，所以提前把oldsize记录下来
        T* tmp = new T[n];
            for (size_t i = 0; i < oldsize; i++)
            {
                tmp[i] = _start[i];
            }
            delete[]_start;
            _start = tmp;
            _finish = _start + oldsize;
            _endofstorage = _start + n;

    }
}

4.4resize()


        void resize(size_t n, const T& value = T())
        {
            if (n < size())//n<size()不改变
            {
                return;
            }
            else
            {
                  int count=size();
                if (n > capacity())//扩容
                {
                    reserve(n);
                }
                    for (int i = size(); i < n; i++)
                     {
                        _start[i] = value;
                     } 
                   _finish+=n-count;
              }
            }

4.5operator[]重载

     T& operator[](size_t pos)
 {

     assert(pos < size() && pos >= 0);//判断有效

     return _start[pos];

 }

 const T& operator[](size_t pos)const
 {

     assert(pos < size() && pos >= 0);

     return _start[pos];

 }

4.6返回首尾元素

//返回第一个元素
T& front()
{
	return *_start;
}
const T& front()const
{
	return *_start;
}

//返回最后一个值
T& back()
{
	return _start[size() - 1];
}
const T& back()const
{
	return _start[size() - 1];
}

4.7尾插尾删

    void push_back(const T& x)
{
    if (size() == capacity())
    {
        int newcapacity = capacity() == 0 ? 4 : 2 * capacity();
        reserve(newcapacity);
    }
    _start[size()] = x;
    _finish++;
}

    void pop_back()
    {
        assert(_start < _finish);
        --_finish;
    }

4.8swap()

 void swap(vector<T>& v)
 {
     std::swap(_start, v._start);
     std::swap(_finish, v._finish);
     std::swap(_endofstorage, v._endofstorage);
 }

4.9指定位置插入insert（）

iterator insert(iterator pos, const T& x)
{
	assert(pos >= _start&&pos <= _finish);

    int len=pos-_start;

	if (size() == capacity())
    reserve(size() + 1);

    pos=_start+len;//防止迭代器失效；

	iterator end = _finish;
	while (end != pos)
	{
		*end = *(end - 1);
		end--;
	}
	*pos = x;
	_finish++;
	return pos;
}

4.10指定位置删除erase（）

iterator erase(iterator pos)
{
	assert(pos >= _start&&pos < _finish);
	iterator first = pos + 1;
	while (first != _finish)
	{
		*(first - 1) = *first;
		first++;
	}
	_finish--;
	return pos;
}

4.11清除clear()

void clear()
{
	_finish = _start;
}

五、完整代码

#pragma once
#include<iostream>
#include<assert.h>
namespace hyax
{
    template<class T>
    class vector
    {

    public:

        // Vector的迭代器是一个原生指针

        typedef T* iterator;

        typedef const T* const_iterator;

        iterator begin()
        {
            return _start;
        }

        iterator end()
        {
            return _finish;
        }

        const_iterator begin() const
        {
            return _start;
        }

        const_iterator end() const
        {
            return _finish;
        }
            // construct and destroy

        vector()
        {
            ;
        }

        vector(int n, const T& value = T())
        {
            reserve(n);
            for (int i = 0; i < n; i++)
            {
                _start[i] = value;
            }
            _finish = _start + n;
            
        }


            template<class InputIterator>
            //支持任意容器的迭代器区间初始化
            vector(InputIterator first, InputIterator last)
            {
                while (first != last)
                {
                    push_back(*first);
                    ++first;
                }
            }

            vector(const vector<T>& v)
            {
                if (v._start == nullptr)
                {
                   _start = nullptr;
                   _finish = nullptr;
                   _endofstorage = nullptr;
                }
                else
                {
                T* tmp = new T[v.capacity()];
                _start = tmp;
                _finish = tmp + v.size();
                _endofstorage = tmp+v.capacity();
                for (int i = 0; i < v.size(); i++)
                {
                    _start[i] = v._start[i];
                }
                }
                
            }

            vector<T>& operator= (vector<T> v)
            {
                swap(v);
                return *this;
            }

            ~vector()
        {
            if (capacity() > 0)
            {
                delete[]_start;
                _start = _finish = _endofstorage = nullptr;
            }
        }

            // capacity

            size_t size() const
        {
            return _finish - _start;
        }

        size_t capacity() const
        {
            return _endofstorage - _start;
        }
        void reserve(size_t n)
        {
            if (n > capacity())
            {
                size_t oldsize = size();
                T* tmp = new T[n];
                    for (size_t i = 0; i < oldsize; i++)
                    {
                        tmp[i] = _start[i];
                    }
                    delete[]_start;
                    _start = tmp;
                    _finish = _start + oldsize;
                    _endofstorage = _start + n;

            }
        }

        void resize(size_t n, const T& value = T())//一般不缩容
        {
            if (n < size())
            {
                return;
            }
            else
            {
                int count = size();
                if (n > capacity())
                {
                    reserve(n);
                }
                for (int i = size(); i < n; i++)
                {
                    _start[i] = value;
                }
                _finish += n - count;
            }
            }

                T& operator[](size_t pos)
            {

                assert(pos < size() && pos >= 0);

                return _start[pos];

            }

            const T& operator[](size_t pos)const
            {

                assert(pos < size() && pos >= 0);

                return _start[pos];

            }
            //返回第一个元素
            T& front()
            {
                return *_start;
            }
            const T& front()const
            {
                return *_start;
            }

            //返回最后一个值
            T& back()
            {
                return _start[size() - 1];
            }
            const T& back()const
            {
                return _start[size() - 1];
            }



                void push_back(const T& x)
            {
                if (size() == capacity())
                {
                    int newcapacity = capacity() == 0 ? 4 : 2 * capacity();
                    reserve(newcapacity);
                }
                _start[size()] = x;
                _finish++;
            }

                void pop_back()
                {
                    assert(_start < _finish);
                    --_finish;
                }

                void swap(vector<T>& v)
                {
                    std::swap(_start, v._start);
                    std::swap(_finish, v._finish);
                    std::swap(_endofstorage, v._endofstorage);
                }

                iterator insert(iterator pos, const T& x)
                {
                    assert(pos >= _start && pos <= _finish);

                    int len = pos - _start;

                    if (size() == capacity())
                        reserve(size() + 1);

                    pos = _start + len;//防止迭代器失效；

                    iterator end = _finish;
                    while (end != pos)
                    {
                        *end = *(end - 1);
                        end--;
                    }
                    *pos = x;
                    _finish++;
                    return pos;
                }


                iterator erase(iterator pos)
                {
                    assert(pos >= _start && pos < _finish);
                    iterator first = pos + 1;
                    while (first != _finish)
                    {
                        *(first - 1) = *first;
                        first++;
                    }
                    _finish--;
                    return pos;
                }

                void clear()
                {
                    _finish = _start;
                }


    private:

        iterator _start=nullptr; // 指向数据块的开始

        iterator _finish=nullptr; // 指向有效数据的尾

        iterator _endofstorage=nullptr; // 指向存储容量的尾

    };

}

dao_shadow

关注

5
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
从零开始vector的C++模拟实现

第二个参数const T& value = T()，T（）是一个临时对象并且它没有名字（即匿名对象），我们前面用value引用，后面的匿名对象赋值的中间临时变量赋值给value，因为临时对象具有常性，所以这里我们在参数中应该用const修饰.拷贝构造函数需要在起始位置开一个空间和v一样大小的空间即可，然后把v中的数据一个一个拷贝过去。（深拷贝）因为当vector中储存的是自定义类型时，进行浅拷贝只是简单的字节拷贝，会析构两次，程序崩溃。是指向总容量的最后的下一个位置的迭代器。是指向首地址的迭代器，
复制链接

扫一扫