了解vector使用以及模拟实现c++

最新推荐文章于 2024-07-24 14:05:37 发布
最新推荐文章于 2024-07-24 14:05:37 发布
阅读量371 收藏 8
点赞数 8
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44950489/article/details/134952256
版权

了解vector

1.vector是一个表示可变大小数组的序列容器。
2.vector用连续空间存储元素，这意味着可以使用下标访问它的元素，这和数组很像，但是vector是可以动态改变大小的。
3.vector在其尾部进行增加删除的效率较高，在其他位置操作涉及到挪动数据效率较低。

vector

构造函数

image.png
模拟实现
变量

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

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

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

构造函数

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

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

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

            vector(const vector<T>& v)
            {
                reserve(v.capacity());
                for (auto& e : v)
                {
                    push_back(e);
                }
            }
迭代器
** iterator的使用 **接口说明
begin + end获取第一个位置的迭代器和最后一个位置的后一个位置的迭代器
rbegin + rend获取最后一个数据位置的反向迭代器，获取第一个数据前一个位置的反向迭代器

image.png

image.png
模拟实现

        	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;
            }

空间增长问题

image.png
我们在使用vector中不断将元素插入到vector中，vector的容量大小会自动改变，编译器为了效率，会一次增加比较大的空间，具体的是多少视编译器而定
其中有两个点需要我们注意
1.reserve会将容器大小扩容到指定的n，但是如果n比现有的容量要小则不会进行任何操作。
2.resize将vector的size改变到指定的大小n，如果现有size比n要大，则会删除超出n的元素，反之会填充指定的元素。
模拟实现

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

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

            void reserve(size_t n)
            {
                if (n > capacity())//需要扩容
                {
                    T* tmp = new T[n];
                    size_t sz = size();
                    if (_start)
                    {
                        for (int i = 0; i < sz; i++)
                        {
                            tmp[i] = _start[i];
                        }
                        delete[] _start;
                    }
                    _start = tmp;
                    _finish = _start + sz;
                    _endOfStorage = _start + n;
                }
            }

            void resize(size_t n, const T& value = T())
            {
                if (n < size())
                {
                    _finish = _start + n;
                }
                else
                {
                    size_t count =n- size();
                    while (count--)
                    {
                        push_back(value);
                    }
                }
            }

增删查改

image.png
迭代器失效问题，vector的迭代器的底层是一个指针，我们在使用迭代器的时候，如果中途遇到改变底层空间的操作都有可能会引起迭代器失效（ resize、reserve、insert、assign、 push_back等 ）

vector<int> v{1,2,3,4,5,6};
 
auto it = v.begin();

// 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
// v.resize(100, 8);

// 插入元素期间，可能会引起扩容，而导致原空间被释放
// v.insert(v.begin(), 0);
// v.push_back(8);

原因就是上面的操作导致vector扩容，原空间被释放，这个时候it就是指向一段被释放的空间了
删除操作也会导致迭代器失效

int a[] = { 1, 2, 3, 4 };

vector<int> v(a, a + sizeof(a) / sizeof(int));

// 使用find查找3所在位置的iterator
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
// 删除pos位置的数据，导致pos迭代器失效。
v.erase(pos);
cout << *pos << endl; // 此处会导致非法访问

模拟实现

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

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



            ///modify/

            void push_back(const T& x)
            {
                /*if (size() == capacity())
                {
                    reserve(size() == 0 ? 4 : size() * 2);
                }
                *_finish = x;
                _finish++;*/
                insert(end(), x);
            }

            void pop_back()
            {
                --_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)
            {
                if (size() == capacity())
                {
                    size_t len = pos - _start;
                    reserve(size() == 0 ? 4 : size() * 2);
                    pos = _start + len;
                }

                
                iterator it = end() - 1;
                while (it >= pos)//挪动数据
                {
                    *(it + 1) = *it;
                    it--;
                }
                *pos = x;
                _finish++;
                
                
                return pos;
            }

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

完整代码

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()
                :_start(nullptr)
                ,_finish(nullptr)
                ,_endOfStorage(nullptr)
            {}

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

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

            vector(const vector<T>& v)
            {
                reserve(v.capacity());
                for (auto& e : v)
                {
                    push_back(e);
                }
            }

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

            ~vector()
            {
                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())//需要扩容
                {
                    T* tmp = new T[n];
                    size_t sz = size();
                    if (_start)
                    {
                        for (int i = 0; i < sz; i++)
                        {
                            tmp[i] = _start[i];
                        }
                        delete[] _start;
                    }
                    _start = tmp;
                    _finish = _start + sz;
                    _endOfStorage = _start + n;
                }
            }

            void resize(size_t n, const T& value = T())
            {
                if (n < size())
                {
                    _finish = _start + n;
                }
                else
                {
                    size_t count =n- size();
                    while (count--)
                    {
                        push_back(value);
                    }
                }
            }



            ///access///

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

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



            ///modify/

            void push_back(const T& x)
            {
                /*if (size() == capacity())
                {
                    reserve(size() == 0 ? 4 : size() * 2);
                }
                *_finish = x;
                _finish++;*/
                insert(end(), x);
            }

            void pop_back()
            {
                --_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)
            {
                if (size() == capacity())
                {
                    size_t len = pos - _start;
                    reserve(size() == 0 ? 4 : size() * 2);
                    pos = _start + len;
                }

                
                iterator it = end() - 1;
                while (it >= pos)//挪动数据
                {
                    *(it + 1) = *it;
                    it--;
                }
                *pos = x;
                _finish++;
                
                
                return pos;
            }

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

    private:

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

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

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

    };
qq_44950489
关注
  • 8
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++---vector的使用和模拟实现
qq_47406941的博客
04-03 459
目录 目录 目录 一、接口介绍 二、实现 三、测试用例 四、迭代器失效 一、接口介绍 1、插入数据 void push_back(const T& x) 在当前vector尾部插入x,如果容量不够扩大二倍。 iterator insert(iterator pos, const T& x) 在POS位置插入元素x 2、容量相关 size_t capacity() 返回当前vector的容量（size+剩余容量）...
c++stl之 vector的底层理解及其模拟实现
qq_54626677的博客
11-26 307
示例代码// a copy of third // 下面涉及迭代器初始化的部分，我们学习完迭代器再来看这部分 // the iterator constructor can also be used to construct from arrays: int myints [ ] = {it!return 0;}
C++ vector使用介绍以及模拟实现
凡事都是靠练习
07-30 840
本文介绍关于C++STL库中的vector容器，了解它的基本接口最后模拟实现vector容器以提高对其理解
C++入门之vector的模拟实现
cls的博客
03-26 1115
vector源代码的大致框架,vector本质就是一个模板类 vector的成员变量不再是我们熟悉的size，capacity，而是变成了功能一致的三个指针 namespace pxl { template<class T> class vector { public: typedef T* iterator; private: iterator _start; iterator _finish; iterator _endofstora.
vector的使用及模拟实现（c++）
weixin_65665343的博客
09-18 732
vector 的使用及模拟还需要优化
c++ vector模拟实现代码
08-25
这个模拟实现包括了基本的构造函数、析构函数、查询函数以及`reserve`方法。注意，真实的STL `vector`实现还包括其他功能，如`push_back`、`pop_back`、`insert`、`erase`等，这些操作都需要处理元素移动和内存管理...
C++模拟实现vector
03-07
C++模拟实现vector
模拟实现Vector的基本功能
05-26
用c++开发语言，模拟是下std标准库中的Vector基本的功能，复习下Vector标准库的相关知识，特留下此笔记
C++的Vector实现.zip
08-20
本项目的目标是实现一个自定义的`Myvector`类，模拟`std::vector`的部分功能。 `std::vector`的核心特性包括： 1. 动态增长：当向vector中添加元素，且当前容量不足时，vector会自动分配更大的内存空间并复制现有...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1183
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 266
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1126
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
C++ | Leetcode C++题解之第275题H指数II
Ddddddd_158的博客
07-23 366
C++ | Leetcode C++题解之第275题H指数II
Delphi5实现鱼C屏幕保护程序
最新发布
weixin_52116519的博客
07-24 353
使用Form1的events的oncreate事件，双击命名为FormCreate。即上面的“- □ ×”不显示。
C++ 红黑树
wxk2227814847的博客
07-22 1099
在之前的文章中，我们介绍了 C++ 标准库中的 map 和 set 容器的使用，以及 AVL 树的实现。尽管 AVL 树在平衡性方面表现优异，但在插入和删除操作频繁的应用中，红黑树（Red-Black Tree）由于其较少的旋转操作次数，往往能提供更优的性能。本篇博客将详细介绍红黑树的概念、性质、节点定义、结构、插入与删除操作、性能、迭代器设计，并展示基于红黑树的模拟实现代码及其在 map 容器中的应用。
linux C++ onnxruntime yolov8 视频检测Demo
.NET 人工智能实践
07-23 711
linux C++ onnxruntime yolov8 视频检测Demo
C++中的模板函数和模板类
2302_81171591的博客
07-22 679
T1 ,classT2 ,... ,classTnclass类模板名//类内成员定义。
【C++】详解 set | multiset
2301_80171004的博客
07-22 1338
本文探讨了C++标准模板库中set与multiset容器的使用，涵盖构造、插入、查找、删除等基本操作，并解析lower_bound、upper_bound及equal_range函数的高效区间搜索机制，为高效数据管理提供实战指南。
洛谷 P10732 [NOISG2019 Prelim] Palindromic FizzBuzz
wang__1233的博客
07-23 437
这题是判断 S 和 E 的区间的数是否为回文数，而回文数有一个非常简单的判断方法，那就是把数字用 to_string 转成然后复制下来，接着将复制来的通过 reverse 反转，最后判断两个字符串是否相同即可。
c++模拟实现vector
09-01
引用和提供了关于实现vector的两种方法。其中，引用展示了一个使用reserve和push_back方法的示例，而引用展示了一个使用new和memcpy函数的示例。这两种方法都是常见的实现vector的方式。 在第一种方法中，通过reserve函数可以预留足够的内存空间，然后使用push_back函数逐个将元素添加到vector中。这种方法的好处是可以避免不必要的内存重分配，提高了效率。 而第二种方法使用new操作符在堆上分配内存空间，并使用memcpy函数将已有的vector对象的数据复制到新的内存空间中。通过这种方式，可以实现深拷贝，即两个vector对象拥有独立的内存空间。这种方法的好处是可以在不修改原始vector对象的情况下创建一个新的vector对象。 除了以上两种方法，还可以使用其他方式实现vector类。例如，可以使用动态数组来实现vector的底层数据结构，然后通过成员函数实现vector的各种操作，如增加、删除、查找等。 总结来说，c语言模拟实现vector的关键是动态内存管理和对元素的增删改查操作。可以使用预留空间和逐个添加元素的方式，也可以使用动态数组和复制数据的方式来实现vector类。具体的实现方式可以根据需求和实际情况选择。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *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_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值