C++vector的模拟实现

最新推荐文章于 2024-09-27 11:26:03 发布
最新推荐文章于 2024-09-27 11:26:03 发布
阅读量897 收藏 11
点赞数 20
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjxuec/article/details/141195491
版权

一、vector接口总览

namespace bit

{

  template<class T>

  class vector

  {

  public:

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

    typedef T* iterator；

    typedef const T* const_iterator；

    iterator begin()；

    iterator end()；

    const_iterator cbegin()；

    const_iterator cend() const；



    // construct and destroy

    vector()；

    vector(int n, const T& value = T())；

    template<class InputIterator>

    vector(InputIterator first, InputIterator last)；

    vector(const vector<T>& v)；

    vector<T>& operator= (vector<T> v)；

    ~vector()；

    // capacity

    size_t size() const ；

    size_t capacity() const；

    void reserve(size_t n)；

    void resize(size_t n, const T& value = T())；



    ///access///

    T& operator[](size_t pos)；

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



    ///modify/

    void push_back(const T& x)；

    void pop_back()；

    void swap(vector<T>& v)；

    iterator insert(iterator pos, const T& x)；

    iterator erase(Iterator pos)；

  private:

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

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

    iterator _endOfStorage; // 指向存储容量的尾

  };

}

 为了防止与标准库当中的vector区分，我们将自己模拟实现的vector放在命名空间bit中。

二、模拟实现vector

2.1 默认成员函数的模拟实现

2.1.1 构造函数1

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

这是无参的构造函数，我们实现这个这个函数只需将三个成员变量设置成空指针即可。但C++支持成员变量设置缺省值，所以我们有更简洁的写法。

 vector()
 {}

 private:

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

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

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

给成员变量一个缺省值空指针即可。

 2.1.2 构造函数2

vector(int n, const T& value = T())
{
    reserve(n);
    for (size_t i = 0; i < n; i++)
    {
        push_back(value);
    }
}

这个构造函数可以使用n个value来初始化vector，我们先用reserve开好n个空间，最后将value依次尾插到开好的空间即可。

2.1.3 构造函数3

template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
    while (first != last)
    {
        push_back(*first);
        ++first;
    }
}

这是用一段迭代器区间来对vector进行初始化，迭代器区间是其他容器的迭代器区间，对于其他容器的类型是不确定的，所以我们在这里要设计成函数模板，最后将每个数据依次尾插到容器中即可。

2.1.4 拷贝构造函数

vector(vector<T>& v)
{
    reserve(v.size());
    for (auto& x : v)
    {
        push_back(x);
    }
}

拷贝构造函数的实现也十分简单，首先先开好空间，再用范围for遍历容器，最后将数据依次尾插到新容器中即可。 

这里选需要注意深浅拷贝问题，如果使用memcpy函数进行拷贝，那么我们如果释放了旧空间，我们将找不到数据所在的空间了，因为memcpy是浅拷贝，两个容器实际上是共用一段空间，如果释放了旧空间，那么拷贝过后的容器也找不到数据，空间以及被释放掉了。

 2.1.5 赋值重载函数

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

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

赋值重载函数只需调用一个swap函数即可实现，而swap函数则是调用了标准库当中的swap函数，我们交换两个容器的值，那么左值与右值就交换了，便完成了赋值。

这里一样要注意深浅拷贝问题，一样不能使用memcpy进行拷贝，这种写法就是深拷贝。 

2.1.6 析构函数

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

析构函数也十分简单，我们首先先判断容器是否为空，如果不为空就将所开的空间释放掉，再将三个指针都置为空指针。

2.2 迭代器相关函数的实现

typedef T* iterator;

typedef const T* const_iterator;

vector的迭代器实际上就是一个原生指针，是当前数据类型的指针。

2.2.1 begin和end的模拟实现

 iterator begin()
 {
     return _start;
 }

 iterator end()
 {
     return _finish;
 }

begin返回容器的首地址，end返回容器当中有效数据的下一个位置。

2.3 容量和大小函数的模拟实现

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

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

size返回的是当前容器的数据个数，capacity返回的是当前容器的容量，我们用_finish-_start就可以得出数据个数，同样的用_endOfStorage - _start就可以得出当前容器的容量。

2.4 reserve函数的模拟实现

 template<class T>
 void bit::vector<T>::reserve(size_t n)
 {
     if (n > capacity())
     {
         size_t old_size = size();
         T* temp = new T[n];
         for (size_t i = 0; i < old_size; i++)
         {
             temp[i] = _start[i];
         }
         delete[] _start;
         _start = temp;
         _finish = _start + old_size;
         _endOfStorage = _start + n;
     }
 }

这里要注意reserve的扩容规则，如果n<capacity那么就不扩容，只有n>capacity的时候才进行扩容。 在扩容的时候我们要先将原先容器的长度记录下来，

 

在扩容完后，_start以及指向temp了，但此时的_finish还是指向原来容器的末尾，此时也要对_finish进行更新，而_start+old_size就是新容器_finish所指向的位置，所以在释放空间前要先记录原容器的长度，这样才能找到新容器中_finish所指向的准确位置，不对_finish进行更新，_finish-_size就会得出随机值，所得出的有效数据的个数就是错误的。

在这里一样要注意深浅拷贝的问题，我们一样不能够使用memcpy进行拷贝，否则释放旧空间时就找不到数据了。

 

2.5 resize函数的模拟实现

template<class T>
void bit::vector<T>::resize(size_t n, const T& value)
{
    if (n < size())
    {
        _finish = _start + n;
    }
    else
    {
        reserve(n);
        while (_finish < _start + n)
        {
            *_finish = value;
            ++_finish;
        }
    }
}

这里也要注意resize的规则，如果n<size则是进行删除，最终容器中只剩下n个数据，当n>size时就是进行尾插，尾插_start+n-_finish个数据。

void resize(size_t n, const T& value = T());

这是resize函数的声明， value给的缺省值T()主要是为了应对string未初始化的情况，当然C++的内置类型也有自己的默认构造函数，所以内置类型未初始化也可以应用这个缺省值。

2.6 empty函数的模拟实现

bool empty()const
{
    return _start == _finish;
}

empty可以判断该容器是否为空，我们只需判断_start和_finish两个指针的位置即可判断容器是否为空。

 

2.7 push_back函数的模拟实现

void push_back(const T& x)
{
    if (_finish == _endOfStorage)
    {
        reserve(capacity() == 0 ? 4 : 2 * capacity());
    }
    *_finish = x;
    ++_finish;
}

 首先判断容器的容量是否满了，满了需要扩容，没满就将数据尾插到_finish位置即可，最后让_finish++。

2.8 pop_back函数的模拟实现

void pop_back()
{
    assert(!empty());
    --_finish;
}

首先要判断容器是否为空，如果容器为空则不能进行尾删，不为空--_finish即可。

2.9 insert函数的模拟实现

template<class T>
T* bit::vector<T>::insert(iterator pos, const T& x)
{
    assert(pos >= _start);
    assert(pos < _finish);
    if (_finish == _endOfStorage)
    {
        size_t lenth = pos - _start;
        reserve(capacity() == 0 ? 4 : 2 * capacity());
        pos = _start + lenth;
    }
    iterator end = _finish + 1;
    while (pos <= end)
    {
        *end = *(end - 1);
        --end;
    }
    *pos = x;
    ++_finish;
    return pos;
}

首先判断位置是否合法，再判断是否需要扩容，在扩容时需要先记录原先容器pos和_start的相对位置，这样才能在扩容后找到要插入的位置，找到要插入的位置后，将pos及pos之后的位置全部往后移一位，最后在pos位置插入数据即可。

这里要注意的问题是，当你插入了一个数据并且还想使用pos位置的指针时，会达不到你想要的结果，这种情况是迭代器失效的问题，如果要想正确的使用pos位置的指针，就必须要对pos指针进行修改。

2.10 erase函数的模拟实现

template<class T>
T* bit::vector<T>::erase(iterator pos)
{
    assert(pos < _finish);
    assert(pos >= _start);
    assert(!empty());
    iterator it = pos + 1;
    while (it != end())
    {
        *(it - 1) = *it;
        ++it;
    }
    --_finish;
    return pos;
}

 erase可以删除pos位置的值，先判断位置是否合法以及容器是否为空，位置合法及容器不为空，就将pos位置之后的每一个数据依次往前挪一位，这样挪完位置之后pos位置的值便被覆盖掉了，完成删除。

2.11 operator[]函数的模拟实现

T& operator[](size_t pos)
{
    assert(pos < size());
    return _start[pos];
}

const T& operator[](size_t pos)const
{
    assert(pos < size());
    return _start[pos];
}

这是实现通过下标访问容器中的数据，我们只需检查下pos是否合法，合法返回pos所指向位置的值即可。

 

三、模拟实现vector完整代码

vector.h文件:

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;

namespace bit

{

    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 cbegin()
        {
            return _finish;
        }

        const_iterator cend() const
        {
            return _start;
        }



            // construct and destroy

        vector()
        {}

        vector(int n, const T& value = T())
        {
            reserve(n);
            for (size_t i = 0; i < n; i++)
            {
                push_back(value);
            }
        }

        template<class InputIterator>
        vector(InputIterator first, InputIterator last)
        {
            while (first != last)
            {
                push_back(*first);
                ++first;
            }
        }

        vector(vector<T>& v)
        {
            reserve(v.size());
            for (auto& x : v)
            {
                push_back(x);
            }
        }

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

        ~vector()
        {
            if (_start)
            {
                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);

        void resize(size_t n, const T& value = T());



            ///access///

        T& operator[](size_t pos)
        {
            assert(pos < size());
            return _start[pos];
        }

        const T& operator[](size_t pos)const
        {
            assert(pos < size());
            return _start[pos];
        }



            ///modify/

        void push_back(const T& x)
        {
            if (_finish == _endOfStorage)
            {
                reserve(capacity() == 0 ? 4 : 2 * capacity());
            }
            *_finish = x;
            ++_finish;
        }

        bool empty()const
        {
            return _start == _finish;
        }

        void pop_back()
        {
            assert(!empty());
            --_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);

        iterator erase(iterator pos);

    private:

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

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

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

    };

    template<class T>
    void bit::vector<T>::reserve(size_t n)
    {
        if (n > capacity())
        {
            size_t old_size = size();
            T* temp = new T[n];
            for (size_t i = 0; i < old_size; i++)
            {
                temp[i] = _start[i];
            }
            delete[] _start;
            _start = temp;
            _finish = _start + old_size;
            _endOfStorage = _start + n;
        }
    }

    template<class T>
    void bit::vector<T>::resize(size_t n, const T& value)
    {
        if (n < size())
        {
            _finish = _start + n;
        }
        else
        {
            reserve(n);
            while (_finish < _start + n)
            {
                *_finish = value;
                ++_finish;
            }
        }
    }

    template<class T>
    T* bit::vector<T>::insert(iterator pos, const T& x)
    {
        assert(pos >= _start);
        assert(pos < _finish);
        if (_finish == _endOfStorage)
        {
            size_t lenth = pos - _start;
            reserve(capacity() == 0 ? 4 : 2 * capacity());
            pos = _start + lenth;
        }
        iterator end = _finish + 1;
        while (pos <= end)
        {
            *end = *(end - 1);
            --end;
        }
        *pos = x;
        ++_finish;
        return pos;
    }

    template<class T>
    T* bit::vector<T>::erase(iterator pos)
    {
        assert(pos < _finish);
        assert(pos >= _start);
        assert(!empty());
        iterator it = pos + 1;
        while (it != end())
        {
            *(it - 1) = *it;
            ++it;
        }
        --_finish;
        return pos;
    }

    template<class container>
    void print_container(container& v)
    {
        for (auto x : v)
        {
            cout << x << " ";
        }
        cout << endl;
    }

    void test_push_back()
    {
        vector<int> v;
        v.push_back(1);
        v.push_back(2);
        v.push_back(3);
        v.push_back(4);
        v.push_back(5);
        print_container(v);
    }

    void test_pop_back()
    {
        vector<int> v;
        v.push_back(1);
        v.push_back(2);
        v.push_back(3);
        v.push_back(4);
        v.push_back(5);
        print_container(v);

        v.pop_back();
        print_container(v);
    }

    void test_operator()
    {
        vector<int> v1;
        v1.push_back(1);
        v1.push_back(2);
        v1.push_back(3);
        v1.push_back(4);
        print_container(v1);

        vector<int> v2 = v1;
        print_container(v2);

        vector<int> v3;
        v3.push_back(10);
        v3.push_back(20);
        v3.push_back(30);

        v1 = v3;
        print_container(v1);
        print_container(v3);
        
        v3[2] = 40;
        print_container(v3);
    }

    void test_insert()
    {
        vector<int> v;
        v.push_back(1);
        v.push_back(2);
        v.push_back(3);
        v.push_back(4);
        v.push_back(5);

        print_container(v);

        int x;
        cin >> x;
        auto p = find(v.begin(), v.end(), x);
        if (p != v.end())
        {
           v.insert(p, 20);
        }
        print_container(v);
    }

    void test_erase()
    {
        vector<int> v;
        v.push_back(1);
        v.push_back(2);
        v.push_back(3);
        v.push_back(4);
        v.push_back(5);

        print_container(v);
        int x;
        cin >> x;
        auto p = find(v.begin(), v.end(), x);
        if (p != v.end())
        {
            v.erase(p);
        }
        print_container(v);
    }
}

test.cpp文件:

#include"vector.h"


int main()
{
	//bit::test_push_back();
	//bit::test_pop_back();
	//bit::test_operator();
	//bit::test_insert();
	bit::test_erase();
	return 0;
}

 

四、 总结

以上便是模拟实现vector函数接口的过程，希望以上所讲能够对大家有所帮助，有帮助的话，别忘了一键三连哦，感谢各位。

zjxuec
关注
【C++详解】——vector模拟实现
weixin_69519040的博客
11-23 1056
本文首先简单介绍了vector，随后模拟实现了vector。 解决了模拟实现过程中，reserve扩容时导致的问题，insert和erase过程中迭代器失效问题，构造函数复用迭代器构造以及构造n个val值时出现的问题，拷贝构造函数中对于自定义类型的处理。
c++ vector模拟实现代码
12-20
下面我们将详细讨论`vector`的主要特点、内部实现原理以及模拟实现的代码解析。 1. **vector的基本特性** - `vector`是一个序列容器，它存储一序列相同类型的对象。 - 它的元素在内存中是连续存储的，因此可以...
C++ vector模拟实现
Wzs040810的博客
01-10 3686
C++ STL vector模拟实现
C++vector模拟实现增删改查
weixin_41368411的博客
04-27 2133
一.成员变量 vector的成员变量有三个，分别是三个类模板参数类型的指针_start，_finish，_endofstorage，它们分别指向vector数组的首个元素，结尾元素的下一个空间，空间末尾。 二.构造函数（默认构造，拷贝构造函数，赋值重载函数，迭代器实现构造函数） vector() :_start(nullptr) ,_finish(nullptr) ,_endofstorage(nullptr) {} //使用迭代器完成构造函数，初.
【C++】vector模拟实现
VHhhbb的博客
07-15 1039
【C++】vector模拟实现
[C++]vector模拟实现
weixin_52345097的博客
03-05 1414
C++vector模拟实现
【C++】vector 模拟实现
m0_51064412的博客
08-05 1583
文章目录一.vector介绍二. vector的模拟实现1. private成员变量及迭代器2. 容量操作接口2.1 size和capacity2.2 reserve2.2 resize3. 默认成员函数3.1 构造函数3.2 拷贝构造3.3 赋值重载4. 修改操作接口4.1 insert4.2 erase 一.vector介绍 vector是表示可变大小数组的序列容器 就像数组一样，vector也采用连续的存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不
C++ 模拟实现vector
Han同学
12-10 2183
C++模拟实现vector
C++_vector简单源码剖析：vector模拟实现
Lvision2的博客
05-25 856
没错，在C++中，内置类型可以像类一样传参初始化，当然就如原本的内置类型一样，不传参就是随机值，传了的那个形参就是参数的值。本文会模拟一个基本的vector类，帮助我们更好的理解vector的内置函数的实现与规则。，cosnt又为这个临时对象赋予常性，就可以起别名，所以这样的语法就可以通过了。这样做有什么好处呢？，我们知道，编译器在我们写了其他的构造函数时是不会生成默认构造的，
C++入门之vector的模拟实现
cls的博客
03-26 1176
vector源代码的大致框架,vector本质就是一个模板类 vector的成员变量不再是我们熟悉的size，capacity，而是变成了功能一致的三个指针 namespace pxl { template<class T> class vector { public: typedef T* iterator; private: iterator _start; iterator _finish; iterator _endofstora.
C++模拟实现vector
03-07
C++模拟实现vector
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 997
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 981
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
pyqt瀑布流布局
weixin_54217201的博客
09-21 478
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
c语言常量变量
小菜鸟的博客
09-26 446
scanfgetsfgets三者的区别scanf1.scanf是一个格式化输入函数，它可以根据指定的格式从标准输入读取数据。2.使用scanf读取字符串时，需要小心处理缓冲区溢出的问题，因为scanf不会自动检查目标缓冲区的大小。3.scanf在读取字符串时遇到空格、制表符或换行符会停止。gets1.gets函数从标准输入读取一行，直到遇到换行符为止，并将换行符替换为字符串结束符\0。2.gets不检查目标缓冲区的大小，因此非常容易导致缓冲区溢出，引发安全问题。
【C++】红黑树的封装——同时实现map和set
最新发布
Mesar的博客
09-27 363
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
c语言-数据类型
m0_69032433的博客
09-22 928
b --> 00000000 00000000 00000000 00001001 --> 9的原码,也是9的补码。... // 百度百科 https://baike.baidu.com/item/c%E8%AF%AD%E8%A8%80/105958?小数部分 1000 00000000 00000000 --> 1 * 2^(-1) --> 0.5。负整数的补码 --> -1 --> 取反 --> 绝对值的原码 --> 得到负数。
Python对于C语言使用者来说的反直觉特性
m0_62710548的博客
09-22 733
在编程领域，从一种语言转向另一种语言总是伴随着一系列的学习和调整。对于习惯了C语言严谨性的程序员来说，转向Python可能会遇到一些令人惊讶的特性。以下是我在短暂学习了一段时间python后察觉到的一些python的特性。
c++模拟实现vector
09-01
- *1* *2* *3* [C++——vector模拟实现](https://blog.csdn.net/weixin_49449676/article/details/126813526)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值