【c++】vector的特性及使用

这篇具有很好参考价值的文章主要介绍了【c++】vector的特性及使用。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一、vector的介绍及使用

1、vector迭代器的使用

2、vector的空间增长

3、vector的迭代器失效问题

二、vector的深度剖析与模拟实现


一、vector的介绍及使用

1、vector迭代器的使用

        vector的迭代器就是原生态指针。vector的迭代器使用方法与string的迭代器使用方法相同。

【c++】vector的特性及使用,c++,开发语言

【c++】vector的特性及使用,c++,开发语言

2、vector的空间增长

【c++】vector的特性及使用,c++,开发语言

        (1)capacity的代码在vs和g++下分别运行会发现,vs下capacity是按1.5倍增长的,g++是按2倍增长的。

        (2)reserve只负责开辟空间,如果确定知道需要用多少空间,reserve可以缓解vector增容的代价缺陷问题。

        (3)resize在开空间的同时还会进行初始化,影响size。

3、vector的迭代器失效问题

        迭代器的主要作用就是让算法不用关心底层数据结构,其底层实际就是一个指针,或者是对指针进行了封装。比如:vector的迭代器就是原生态指针T*,因此迭代器失效实际就是迭代器底层对应指针所指向的空间被销毁了,而使用一块被释放的空间,造成的后果是程序崩溃(即如果继续使用已经失效的迭代器,程序可能会崩溃)。对于vector可能会导致其迭代器失效的操作有:

        (1)会引起底层空间改变的操作,都有可能导致迭代器失效。如:resize、reserve、insert、push_back等。

                以上操作都有可能导致vector扩容,即vector底层原来的旧空间被释放,而再打印时it还使用的释放之前的旧空间,在对it迭代器操作时,实际操作的是一块已经被释放掉的空间,从而引起代码运行崩溃。如果想要继续通过迭代器操作vector中的元素,只需给it重新赋值即可。

        (2)指定位置元素的删除操作---erase

                erase删除pos位置元素后,pos位置之后的元素会往前移动,没有导致底层空间的变化,理论上讲迭代器不应该失效,但是:如果pos刚好是最后一个元素,删除掉最后一个元素之后pos就变成了end的位置,而end位置是没有有效元素的,那么pos就会失效。因此,删除vector中任意位置上元素时,vs就会认为

        (3)Linux下,g++编译器对迭代器失效的检测并不是非常严格,处理也没有vs那么极端:

                a、扩容后,迭代器已经失效了,程序虽然可以运行,但是运行结果会发生变化。

                b、erase删除任意位置代码后,Linux下的迭代器不会失效,因为空间还是原来的空间,后续元素整体往前移动,it的位置还是有效的。

                c、erase删除的迭代器如果是最后一个元素,删除之后it已经超过end,此时迭代器失效,++it导致迭代器失效。

                总结:Linux中,迭代器失效后代码并不一定会崩溃,但是运行结果一定会改变,如果it不在begin和end的范围内,程序一定崩溃。

二、vector的深度剖析与模拟实现

        以vector的(push_back())尾插为例剖析其底层逻辑:

【c++】vector的特性及使用,c++,开发语言

        vector的增删查改模拟实现:文章来源地址https://www.toymoban.com/news/detail-805364.html

//模拟实现vector类,并完成测试
namespace lbj
{
    template<class T>
    class vector
    {
    public:

        // Vector的迭代器是一个原生指针
        typedef T* iterator;
        typedef const T* const_iterator;

        //iterator
        iterator begin()
        {
            return _start;
        }

        iterator end()
        {
            return _finish;
        }

        const_iterator cbegin() const
        {
            return _start;
        }

        const_iterator cend() const
        {
            return _finish;
        }

        // 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)
                {
                    //memcpy(tmp, _start, sizeof(T) * size());
                    for (size_t i = 0; i < size(); 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
            {
                reserve(n);
                while (_finish < _start + n)
                {
                    *_finish = value;
                    _finish++;
                }
            }
        }
        
        //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)
        {
            size_t sz = size();
            if (_finish == _endOfStorage)
            {
                reserve(capacity() == 0 ? 5 : capacity() * 2);
            }
            *_finish = x;
            _finish++;
        }

        void pop_back()
        {
           --_finish;
        }

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

        void insert(iterator pos, const T& x)
        {
            assert(pos >= _start);
            assert(pos <= _finish);
            if (_finish == _endOfStorage)
            {
                size_t len = pos - _start;
                reserve(capacity() == 0 ? 5 : capacity() * 2);
                pos = _start + len;
            }
            iterator end = _finish - 1;
            while (end >= pos)
            {
                *(end + 1) = *end;
                end--;
            }
            *pos = x;
            _finish++;
        }

        void erase(iterator pos)
        {
            assert(pos >= _start);
            assert(pos < _finish);
            iterator it = pos + 1;
            while (it < _finish)
            {
                *(it - 1) = *it;
                it++;
            }
            _finish--;
        }

        // construct and destroy
        vector()
            :_start(nullptr)
            , _finish(nullptr)
            , _endOfStorage(nullptr)
        {}

        vector(int n, const T& value = T())
            :_start(nullptr)
            , _finish(nullptr)
            , _endOfStorage(nullptr)
        {
            resize(n, value);
        }

        template<class InputIterator>   //类模板里边的模板函数
        vector(InputIterator first, InputIterator last)    //迭代器区间是左闭右开的形式
        {
            while (first != last)
            {
                push_back(*first);
                first++;
            }
        }

        vector(vector<T>& v)
            :_start(nullptr)
            , _finish(nullptr)
            , _endOfStorage(nullptr)
        {
            reserve(v.capacity());
            for (auto num : v)
            {
                push_back(num);
            }
        }

        vector<T>& operator= (vector<T> v)  //传值:会调用拷贝构造,生成临时对象,函数里边改变临时对象不会改变v的值
        {
            swap(v);
            return *this;
        }

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

    private:
        iterator _start; // 指向数据块的开始
        iterator _finish; // 指向有效数据的尾
        iterator _endOfStorage; // 指向存储容量的尾
    };
}

到了这里,关于【c++】vector的特性及使用的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【C++】vector 基本使用(详解)

    目录 一,vector 的介绍 二,vector 的定义 1,vector() 2,vector(size_type n, const value_type val = value_type()) 3,vector (const vector x) 4,vector (InputIterator first, InputIterator last); 三,vector iterator 的使用 1,begin + end 2,rbegin + rend  四,vector 空间增长问题 1,size 2,capacity 3,empty 4,reserve 5,

    2024年02月03日
    浏览(38)
  • [C++]vector的介绍及使用

    目录 C++:vector的使用                 1.vector的定义方式                 2.vector的空间增长                         size和capacity                         reserve和resize                         empty                 3.ve

    2024年02月08日
    浏览(46)
  • 【C++】vector的介绍与使用

      🧑‍🎓 个人主页:简 料   🏆 所属专栏:C++   🏆 个人社区:越努力越幸运社区   🏆 简       介: 简料简料,简单有料~在校大学生一枚,专注C/C++/GO的干货分享,立志成为您的好帮手 ~ C/C++学习路线 (点击解锁) ❤️ C语言 ❤️ 初阶数据结构与算法 ❤️ C++ ❤️

    2024年02月04日
    浏览(44)
  • C++:vector使用以及模拟实现

    和我们原来讲的string不同, vector并不是类,是一个类模板,加类型实例化以后才是类。 vector是表示 可变大小数组 的序列容器。 像数组一样 ,vector也采用的连续存储空间来存储元素,但是容量可以动态改变。 和其它容器相比,vector访问元素、尾插、尾删较高效,但不在尾部

    2024年02月11日
    浏览(43)
  • C++学习——vector类的使用

    目录 vector类的介绍: vector类的构造函数:   operator=   operator [ ]    begin end   size resize   capacity reserve   push_back pop_back   insert erase   vector是C++标准模板库中的部分内容,中文偶尔译作“容器”,但并不准确。它是一个多功能的,能够操作多种数据结构和算法的模板类和函数

    2024年02月09日
    浏览(37)
  • “C++基础入门指南:了解语言特性和基本语法”

    C++是在C的基础之上,容纳进去了面向对象编程思想,并增加了许多有用的库,以及编程范式 等。熟悉C语言之后,对C++学习有一定的帮助 工作之后,看谁的技术牛不牛逼,不用看谁写出多牛逼的代码,就代码风格扫一眼,立刻就能看出来是正规军还是野生的程序员。代码的风

    2024年02月16日
    浏览(39)
  • 【C++庖丁解牛】STL之vector容器的介绍及使用 | vector迭代器的使用 | vector空间增长问题

    🍁你好,我是 RO-BERRY 📗 致力于C、C++、数据结构、TCP/IP、数据库等等一系列知识 🎄感谢你的陪伴与支持 ,故事既有了开头,就要画上一个完美的句号,让我们一起加油 vector的文档介绍 vector是表示可变大小数组的序列容器。 就像数组一样,vector也采用的连续存储空间来存

    2024年03月14日
    浏览(79)
  • 【C++】vector的使用及其模拟实现

    vector 是表示 可变大小数组的序列容器。 就像数组一样,vector也采用的连续存储空间来存储元素。也就是意味着可以 采用下标对vector的元素进行访问 ,和数组一样高效。但是又不像数组, 它的大小是可以动态改变的,而且它的大小会被容器自动处理。 本质讲,vector使用动态

    2024年02月02日
    浏览(42)
  • C++【STL】之vector的使用

    vector是表示可变大小数组的序列容器。 就像数组一样,vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问,和数组一样高效。但是又不像数组,它的大小是可以动态改变的,而且它的大小会被容器自动处理。 本质讲,vector使用动态分

    2024年02月09日
    浏览(50)
  • 【C++】vector的使用及模拟实现

    vector是一个可变大小数组的容器,与数组一样,vector也是一块连续的空间,可以像数组一样对元素进行高效的遍历访问,但是普通数组的大小是不变的,vector可以改变自身大小。vector是采用动态分配数组来存储数据,即插入新元素时要改变存储空间大小,往往要分配一个新的

    2024年01月16日
    浏览(52)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包