C++STL专题 vector底层实现

于 2024-08-06 17:44:07 发布
阅读量1.1k 收藏 19
点赞数 15
分类专栏： C++初阶 文章标签： c++ 算法 开发语言 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80122797/article/details/140957571
版权

目录

一， vector的手搓

1.构造函数

2. 拷贝构造的实现

3.析构函数

4.begin() end() 的实现

5.reserve的实现

6.size和capacity的实现

7.push_back的实现

8.pop_back的实现

9.empty的实现

10.insert的实现

11.erase的实现

12.resize的实现

13.clear的实现

14.swap的实现

14. []重载

15.=重载

16. Vector类中的private

二，源码

一， vector的手搓

Vector类的定义

template <class T>
class Vector
{
public:
    typedef T* iterator;
    typedef const T* const_iterator;

    Vector()
    {}



private:
    iterator _start = nullptr;//最开始
    iterator _finish = nullptr;//内容结尾(并不是容量的结尾)
    iterator _end_of_storage = nullptr;//容量结尾
};

1.构造函数

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

(1).在模板类中再定义模板类，使得能够插入不同容器的值。

2. 拷贝构造的实现

Vector(const Vector<T>& v)//拷贝构造
{
    for (auto& e : v)
    {
        Push_back(e);
    }
}

(1).直接使用范围for遍历一次即可。

3.析构函数

~Vector()
{
    if (_start)
    {
        delete[] _start;
        _start = _finish = _end_of_storage = nullptr;
    }
}

(1).如果_start不空的话，就使用delete[] 释放空间。并且置空。

 

4.begin() end() 的实现

iterator begin()
{
    return _start;
}

iterator end()
{
    return _finish;
}

const_iterator begin() const
{
    return _start;
}

const_iterator end() const
{
    return _finish;
}

(1).分为const修饰和不加const修饰，构成了函数重载，begin()返回起始_start即可，end()返回_finsih即可。

5.reserve的实现

void Reserve(size_t n)
{
    if (n > Capacity())
    {
        size_t oldsize = Size();
        T* tmp = new T[n];

        for (int i = 0; i < oldsize; i++) {
            tmp[i] = _start[i];
        }

        //memcpy(tmp, _start, Size() * sizeof(T));
        delete[] _start;

        _start = tmp;
        _finish = tmp + oldsize;
        _end_of_storage = tmp + n;
    }
}

(1).扩容函数，如果要求的空间大于当前的容量，就要扩容，首先存储当先数据个数Size()到oldsize，然后再开辟一个新空间，然后把_start中的全部数据拷贝到tmp中，然后再把_start释放空间，再将tmp赋值给_start，将_finish指向tmp+oldsize的位置。_end_of_storage指向tmp+n的位置。

6.size和capacity的实现

size_t Size()
{
    return _finish - _start;
}

size_t Capacity()
{
    return _end_of_storage - _start;
}

(1).Size为vector中数据个数，所以直接返回_finish(最后一个数据的地址)减start(第一个数据的地址)即可。

(2).Capacity为vector中容量大小，所以直接返回_end_of_storage(容量的最后一个地址)减start(第一个数据的地址)即可。

7.push_back的实现

void Push_back(const T& x)
{
    if (_finish == _end_of_storage) // 扩容
    {
        Reserve(Capacity() == 0 ? 4 : Capacity() * 2);
    }
    *_finish = x;
    ++_finish;
}

(1).push_back前要检查是否需要扩容，这里选择二倍扩容。

(2).直接将*_finish(元素的最后一个位置的下一个位置)赋值为x。再将_finish自加，使其移动到空位置，方便下次赋值。

8.pop_back的实现

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

(1).首先判断是否为空，如果为空就断言。

(2).直接将_finish自减即可。

9.empty的实现

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

(1).判断_start 和 _finish是否相等即可，如果相等就为空，否则为不空。

10.insert的实现

iterator insert(iterator pos, const T& x)
{
    assert(pos >= _start);
    assert(pos <= _finish);
    if (_finish == _end_of_storage) // 扩容
    {
        size_t len = pos - _start; // 解决迭代器失效
        Reserve(Capacity() == 0 ? 4 : Capacity() * 2);
        pos = _start + len; // 解决迭代器失效
    }

    iterator end = _finish - 1;
    while (end >= pos) // 迭代器失效问题已经扩容了，但是pos还是指向原来的旧空间 野指针
    {
        *(end + 1) = *end;
        end--;
    }
    *pos = x;
    ++_finish;

	return pos;
}

(1).大致思路为把要插入位置(pos)之后的全部向后移动一位，然后再将pos位置赋值为要插入的元素。

(2).要想插入，首先判断是否需要扩容。

(3).定义一个迭代器end，存储vector中最后一个元素的位置，然后循环判断(end >= pos)，每次成立时，就把end+1处赋值为end的元素，然后将end自减。退出循环后，直接将*pos赋值为x并把_finish自加即可。

11.erase的实现

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

(1).大致思路为将pos位置之后的全部元素都向前移动一个位置，最后将_finish自减即可。

12.resize的实现

void resize(size_t n, T val = T())
{
    // n<size
    // size<n<capacity
    // n>capaciity
    if (n < Size())
    {
        _finish = _start + n;
    }
    else
    {
        Reserve(n);
        while (_finish < _start + n)
        {
            *_finish = val;
            ++_finish;
        }
    }
}

(1).resize为对字符串大小做改变，当n<size时，就会对当前字符串缩减，其余情况为reserve。

13.clear的实现

void clear()
{
    _finish = _start;
}

(1).直接将_finish=_start即可。

14.swap的实现

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

(1).直接交换即可。

14. []重载

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

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

(1).由于_start为顺序表，所以直接返回顺序表的值即可。

15.=重载

//方法一：

Vector<T>& operator=(const Vector<T>& v)
{
    if (this != &v)
    {
        clear();
        Reverse(v.Size());
        for (auto& e : v)
        {
            Push_back(e);
        }
    }
    return *this;
}

//方法二：
 Vector<T>& operator=( vector<T> v)
 {
     swap(v);
     return *this;
 }

(1).有两种方法，第一种方法为先清空_start，然后再对_start重新扩容，扩容置与v相等，然后遍历v，把v中的元素按个插入_start。

(2).方法二：要进行传值传参，不能用传址传参，然后直接交换即可，这样_start就成了v了，由于v为传值传参，并不受影响。

16. Vector类中的private

private:
    iterator _start = nullptr;//缺省
    iterator _finish = nullptr;//缺省
    iterator _end_of_storage = nullptr;//缺省

二，源码

#pragma once
#include <iostream>
#include <vector>
#include <assert.h>
#include<algorithm>

namespace hhc
{
    template <class T>
    class Vector
    {
    public:
        typedef T* iterator;
        typedef const T* const_iterator;

        Vector()
        {}

        Vector(const Vector<T>& v)//拷贝构造
        {
            for (auto& e : v)
            {
                Push_back(e);
            }
        }

        ~Vector()
        {
            if (_start)
            {
                delete[] _start;
                _start = _finish = _end_of_storage = nullptr;
            }
        }

        iterator begin()
        {
            return _start;
        }

        iterator end()
        {
            return _finish;
        }

        const_iterator begin() const
        {
            return _start;
        }

        const_iterator end() const
        {
            return _finish;
        }

        void Reserve(size_t n)
        {
            if (n > Capacity())
            {
                size_t oldsize = Size();
                T* tmp = new T[n];

                for (int i = 0; i < oldsize; i++) {
                    tmp[i] = _start[i];
                }

                //memcpy(tmp, _start, Size() * sizeof(T));
                delete[] _start;

                _start = tmp;
                _finish = tmp + oldsize;
                _end_of_storage = tmp + n;
            }
        }

        size_t Size()
        {
            return _finish - _start;
        }

        size_t Capacity()
        {
            return _end_of_storage - _start;
        }

        void Push_back(const T& x)
        {
            if (_finish == _end_of_storage) // 扩容
            {
                Reserve(Capacity() == 0 ? 4 : Capacity() * 2);
            }
            *_finish = x;
            ++_finish;
        }

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

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

        void insert(iterator pos, const T& x)
        {
            assert(pos >= _start);
            assert(pos <= _finish);
            if (_finish == _end_of_storage) // 扩容
            {
                size_t len = pos - _start; // 解决迭代器失效
                Reserve(Capacity() == 0 ? 4 : Capacity() * 2);
                pos = _start + len; // 解决迭代器失效
            }

            iterator end = _finish - 1;
            while (end >= pos) // 迭代器失效问题已经扩容了，但是pos还是指向原来的旧空间 野指针
            {
                *(end + 1) = *end;
                end--;
            }
            *pos = x;
            ++_finish;
        }

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

        void resize(size_t n, T val = T())
        {
            // n<size
            // size<n<capacity
            // n>capaciity
            if (n < Size())
            {
                _finish = _start + n;
            }
            else
            {
                Reserve(n);
                while (_finish < _start + n)
                {
                    *_finish = val;
                    ++_finish;
                }
            }
        }

        void clear()
        {
            _finish = _start;
        }

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


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

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

        const T& operator[](size_t i) const
        {
            return _start[i];
        }
        //方法一：

        Vector<T>& operator=(const Vector<T>& v)
        {
            if (this != &v)
            {
                clear();
                Reverse(v.Size());
                for (auto& e : v)
                {
                    Push_back(e);
                }
            }
            return *this;
        }

        //方法二：
         Vector<T>& operator=( vector<T> v)
         {
             swap(v);
             return *this;
         }


    private:
        iterator _start = nullptr;
        iterator _finish = nullptr;
        iterator _end_of_storage = nullptr;
    };

    template <class Container>
    void print_Container(const Container& v)
    {
        // 没用实例化的类模板里面取东西，编译器不能区分const_iterator是类型还是静态成员变量
        // 编译器规定不能去没用实例化的模板里面取东西
        typename Container::const_iterator it = v.begin();
        auto itt = v.begin(); // 这样也行
        while (it != v.end())
        {
            std::cout << *it << ' ';
            *it++;
        }
        std::cout << std::endl;
        for (auto num : v)
        {
            std::cout << num << ' ';
        }
    }

}

本篇完

Mike!
关注
专栏目录
STL:vector内部实现原理及基本用法
Taopper的博客
03-07 379
1.vector类的实现 重要结构定义： template<class T> class myVector{ public: typedef T value_type;//元素类型 起别名 typedef value_type* pointer;// typedef value_type* iterator;//迭代器 typedef value_type& reference;//引用 typedef const value_type*
STL vector的内部实现原理及基本用法
热门推荐
qinm的专栏
02-23 4万+
本文基于STL vector源代码，但是不考虑分配器allocator，迭代器iterator，异常处理try/catch等内容，同时对_Ucopy（）、 _Umove（）、 _Ufill（）函数也不会过度分析。一、vector的定义template<class _Ty, class _Ax> class vector : public _Vector_val<_Ty
STL中vector的底层实现
这是书生呀
05-14 830
namespace MyVector{ template<class T> class vector{ public: typedef T* iterator; typedef const T* const_iterator; iterator begin() { return _start; } iterator end() { return _finish; } const_iterator cbegin() const
vector的底层实现！（万字长文详解！）
m0_74376760的博客
11-27 1740
c++之vector的实现！
关于C++STL的总结（基础使用）
最新发布
m0_62126248的博客
04-23 1574
C++ STL六大组件大致总结
C++ STL - vector 模拟实现+解析迭代器
TPON的博客
10-12 1291
STL - vector
C++——STL之vector详解
weixin_59055853的博客
12-21 1842
学习了string之后，学习其他模板将会更容易上手，一起来看一下vector吧！vector是表示大小可以变化的数组的序列容器。
STL中vector的底层实现机制及常用操作
Janway-Win
04-22 1000
本文基于SGI STL vector源码分析其底层实现，只关注核心实现，不考虑空间配置器allocator。 一、vector概述 vector的数据安排以及操作方式，与array非常相似。两者的唯一区别在于空间的运用的灵活性。array是静态空间，一旦配置了就不能改变，要换个大（或小）一点的房子，可以，一切琐细得由客户端自己来：首先配置一块新空间，然后将元素从旧址一一搬往新址，再把原来的空间释还...
C++STL之＜vector＞
gangaue的博客
06-08 927
本篇文章进行STL中vector序列容器的学习！！！【vector文档】举个栗子🌰： 举个栗子🌰： 举个栗子🌰1️⃣： vs运行结果： g++运行结果： 举个栗子🌰2️⃣： 注意：这里的尾插、尾删、insert 和 erase接口跟数据结构中的动态顺序表一样举个栗子🌰1️⃣： 举个栗子🌰2️⃣： 举个栗子🌰3️⃣： 注意：迭代器的作用：比如：对于vector可能会导致其迭代器失效的操作有： 出错原因：解决方式： 指定位置元素删除操作 — erase 程序解析： 程序解析：解决方案：迭代.......
C++初阶：STL之vector类模板
weixin_36194037的博客
12-14 1507
C++初阶：STL之vector类模板
C++ STL底层实现快速查阅
beyongwang的博客
08-28 513
原文链接： http://blog.csdn.net/huangkq1989/article/details/7277282 C++ STL 的实现： 1.vector  底层数据结构为数组 ，支持快速随机访问 2.list    底层数据结构为双向链表，支持快速增删 3.deque   底层数据结构为一个中央控制器和多个缓冲区，详细见STL源码剖析P146，支持首尾（中间不能）快速增删，
C++ 学习笔记：STL 容器一些底层机制
庚午步雲
08-31 5092
vector 容器 list 容器 deque 容器 stack queue heap priority_queue set 和 multiset 容器 map 和 multimap 容器 hash_set 和 hash_multiset 容器 hash_map 和 hash_multimap 容器
深入篇【C++】手搓模拟实现vector类(详细剖析接口底层实现原理)：【200行代码实现】
Extreme_wei的博客
07-17 713
深入篇【C++】手搓模拟实现vector(详细剖析接口底层实现原理)：【200行代码实现】 参考源码，理解底层实现，熟悉的应用SQL中的vector容器，帮助你更好的上手其他容器。
stl容器区别: vector list deque set map及底层实现
倦鸟归时
08-17 4903
在STL中基本容器有: vector、list、deque、set、map set 和map都是无序的保存元素,只能通过它提供的接口对里面的元素进行访问 set :集合, 用来判断某一个元素是不是在一个组里面,使用的比较少 map :映射,相当于字典 ,把一个值
C++STL的容器的底层实现详解
qq_43313035
04-27 1万+
文章目录顺序容器vector(向量容器)deque(双端队列)list关联容器set（集合）multisetmap（key,value）multimap 顺序容器 vector(向量容器) 特点 内存可2倍增长的动态数组 数据结构：线性连续空间 维护三个迭代器：start、finish、end_of_storage 注意：动态增加大小，并不是在原空间之后接续新空间（因为无法保证之后尚有可供...
区别: vector list deque set map
yaokang522的专栏
01-20 519
在STL中基本容器有: vector、list、deque、set、map set 和map都是无序的保存元素,只能通过它提供的接口对里面的元素进行访问 set:集合, 用来判断某一个元素是不是在一个组里面,使用的比较少 map:映射,相当于字典,把一个值映射成另一个值,如果想创建字典的话使用它好了 底层采用的是树型结构,多数使用平衡二叉树实现,查找某一值是常数时间,遍历起来效果也不错,
[C/C++ -STL]vector底层实现机制刨析
qq_50408340的博客
11-21 7946
一、vector底层实现机制刨析 通过分析 vector 容器的源代码不难发现，它就是使用 3 个迭代器（可以理解成指针）来表示的： 其中statrt指向vector 容器对象的起始字节位置； finish指向当前最后一个元素的末尾字节 end_of指向整个 vector 容器所占用内存空间的末尾字节。 如图 演示了以上这 3 个迭代器分别指向的位置 如图 演示了以上这 2个迭代器分别指向的位置 在此基础上，将 3 个迭代器两两结合，还可以表达不同的含义，例如： start 和 finish 可以用来表
STL 容器区别：vector、list、deque、set、map的底层实现
shawjan的专栏
05-01 8453
文章转自：http://blog.csdn.net/lmh12506/article/details/84450251、set和map比较 \ set map 共同点 都是无序的保存元素，只是通过它提供的借口对里面的元素进行访问，底层都是采用红黑树实现 不同点 集合，用来判断某一个元素是不是在一个组里面，使用的比较少 映射，相当于字典，把一个值映射成另一个值，可以
C++ STL详解：向量vector与标准模板库
"向量容器vector是C++标准模板库STL中的一个重要组成部分，它是一个动态数组，能够容纳不定长度的线性序列，并且支持随机访问。STL是C++的一个通用库，由模板类和函数模板组成，强调泛型编程，提供容器、迭代器、...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Mike!

你的鼓励是我创作的最大动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值